

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 	UpperCAmelCase__		:






  """simple docstring"""


  def __init__(							self						:		Optional[int]     ,       __lowerCamelCase						:		Any     ,       __lowerCamelCase						:		str=3     ,       __lowerCamelCase						:		Union[str, Any]=7     ,       __lowerCamelCase						:		List[Any]=True     ,       __lowerCamelCase						:		List[str]=True     ,       __lowerCamelCase						:		List[str]=False     ,       __lowerCamelCase						:		Tuple=True     ,       __lowerCamelCase						:		Any=99     ,       __lowerCamelCase						:		Tuple=32     ,       __lowerCamelCase						:		List[str]=5     ,       __lowerCamelCase						:		Optional[int]=4     ,       __lowerCamelCase						:		Optional[int]=37     ,       __lowerCamelCase						:		Optional[int]="gelu"     ,       __lowerCamelCase						:		Union[str, Any]=0.1     ,       __lowerCamelCase						:		str=0.1     ,       __lowerCamelCase						:		str=512     ,       __lowerCamelCase						:		List[Any]=16     ,       __lowerCamelCase						:		List[str]=2     ,       __lowerCamelCase						:		int=0.02     ,       __lowerCamelCase						:		Dict=3     ,       __lowerCamelCase						:		Union[str, Any]=4     ,       __lowerCamelCase						:		Optional[int]=None     ,       )		->							Any:
       SCREAMING_SNAKE_CASE__   =   parent
       SCREAMING_SNAKE_CASE__   =   batch_size
       SCREAMING_SNAKE_CASE__   =   seq_length
       SCREAMING_SNAKE_CASE__   =   is_training
       SCREAMING_SNAKE_CASE__   =   use_input_mask
       SCREAMING_SNAKE_CASE__   =   use_token_type_ids
       SCREAMING_SNAKE_CASE__   =   use_labels
       SCREAMING_SNAKE_CASE__   =   vocab_size
       SCREAMING_SNAKE_CASE__   =   hidden_size
       SCREAMING_SNAKE_CASE__   =   num_hidden_layers
       SCREAMING_SNAKE_CASE__   =   num_attention_heads
       SCREAMING_SNAKE_CASE__   =   intermediate_size
       SCREAMING_SNAKE_CASE__   =   hidden_act
       SCREAMING_SNAKE_CASE__   =   hidden_dropout_prob
       SCREAMING_SNAKE_CASE__   =   attention_probs_dropout_prob
       SCREAMING_SNAKE_CASE__   =   max_position_embeddings
       SCREAMING_SNAKE_CASE__   =   type_vocab_size
       SCREAMING_SNAKE_CASE__   =   type_sequence_label_size
       SCREAMING_SNAKE_CASE__   =   initializer_range
       SCREAMING_SNAKE_CASE__   =   num_labels
       SCREAMING_SNAKE_CASE__   =   num_choices
       SCREAMING_SNAKE_CASE__   =   scope






  def 				lowercase_		(							self						:		List[str] )		->							Optional[Any]:
       SCREAMING_SNAKE_CASE__   =   ids_tensor([self.batch_size, self.seq_length]     ,       self.vocab_size )

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

       SCREAMING_SNAKE_CASE__   =   None

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

       SCREAMING_SNAKE_CASE__   =   self.get_config()

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






  def 				lowercase_		(							self						:		Optional[int] )		->							int:
       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 				lowercase_		(							self						:		str     ,       __lowerCamelCase						:		Any     ,       __lowerCamelCase						:		Union[str, Any]     ,       __lowerCamelCase						:		Optional[Any]     ,       __lowerCamelCase						:		Tuple     ,       __lowerCamelCase						:		Dict     ,       __lowerCamelCase						:		Tuple     ,       __lowerCamelCase						:		Optional[Any] )		->							Union[str, Any]:
       SCREAMING_SNAKE_CASE__   =   FalconModel(config=__lowerCamelCase )
       model.to(__lowerCamelCase )
       model.eval()
       SCREAMING_SNAKE_CASE__   =   model(__lowerCamelCase     ,       attention_mask=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   model(__lowerCamelCase )
       self.parent.assertEqual(result.last_hidden_state.shape     ,       (self.batch_size, self.seq_length, self.hidden_size) )






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






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






  def 				lowercase_		(							self						:		Any     ,       __lowerCamelCase						:		str     ,       __lowerCamelCase						:		Optional[int]     ,       __lowerCamelCase						:		List[Any]     ,       __lowerCamelCase						:		str     ,       __lowerCamelCase						:		Dict     ,       __lowerCamelCase						:		str     ,       __lowerCamelCase						:		Any     ,       __lowerCamelCase						:		Dict     ,       __lowerCamelCase						:		List[str]     ,       )		->							Union[str, Any]:
       SCREAMING_SNAKE_CASE__   =   True
       SCREAMING_SNAKE_CASE__   =   True
       SCREAMING_SNAKE_CASE__   =   FalconForCausalLM(config=__lowerCamelCase )
       model.to(__lowerCamelCase )
       model.eval()

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

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

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

       SCREAMING_SNAKE_CASE__   =   model(
           __lowerCamelCase     ,       attention_mask=__lowerCamelCase     ,       encoder_hidden_states=__lowerCamelCase     ,       encoder_attention_mask=__lowerCamelCase     ,       output_hidden_states=__lowerCamelCase     ,       )['''hidden_states'''][0]
       SCREAMING_SNAKE_CASE__   =   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
       SCREAMING_SNAKE_CASE__   =   ids_tensor((1,)     ,       output_from_past.shape[-1] ).item()
       SCREAMING_SNAKE_CASE__   =   output_from_no_past[:, -3:, random_slice_idx].detach()
       SCREAMING_SNAKE_CASE__   =   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 				lowercase_		(							self						:		Optional[int] )		->							Dict:
       SCREAMING_SNAKE_CASE__   =   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__
       ),
       )   =   config_and_inputs
       SCREAMING_SNAKE_CASE__   =   {'''input_ids''': input_ids, '''attention_mask''': input_mask}
       return config, inputs_dict






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






  """simple docstring"""


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






  def 				lowercase_		(							self						:		int )		->							Optional[int]:
       SCREAMING_SNAKE_CASE__   =   FalconModelTester(self )
       SCREAMING_SNAKE_CASE__   =   ConfigTester(self     ,       config_class=__lowerCamelCase     ,       hidden_size=37 )






  def 				lowercase_		(							self						:		Any )		->							Union[str, Any]:
       self.config_tester.run_common_tests()






  def 				lowercase_		(							self						:		int )		->							List[Any]:
       SCREAMING_SNAKE_CASE__   =   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*__lowerCamelCase )






  def 				lowercase_		(							self						:		Union[str, Any] )		->							List[Any]:
       SCREAMING_SNAKE_CASE__,*SCREAMING_SNAKE_CASE__   =   self.model_tester.prepare_config_and_inputs()
       for alibi in [True, False]:
            SCREAMING_SNAKE_CASE__   =   alibi
            self.model_tester.create_and_check_model(__lowerCamelCase     ,       *__lowerCamelCase )






  def 				lowercase_		(							self						:		List[Any] )		->							Optional[Any]:
       SCREAMING_SNAKE_CASE__,SCREAMING_SNAKE_CASE__   =   self.model_tester.prepare_config_and_inputs_for_common()
       SCREAMING_SNAKE_CASE__   =   3
       SCREAMING_SNAKE_CASE__   =   input_dict['''input_ids''']
       SCREAMING_SNAKE_CASE__   =   input_ids.ne(1 ).to(__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   ids_tensor([self.model_tester.batch_size]     ,       self.model_tester.type_sequence_label_size )
       SCREAMING_SNAKE_CASE__   =   FalconForSequenceClassification(__lowerCamelCase )
       model.to(__lowerCamelCase )
       model.eval()
       SCREAMING_SNAKE_CASE__   =   model(__lowerCamelCase     ,       attention_mask=__lowerCamelCase     ,       labels=__lowerCamelCase )
       self.assertEqual(result.logits.shape     ,       (self.model_tester.batch_size, self.model_tester.num_labels) )






  def 				lowercase_		(							self						:		List[Any] )		->							Optional[Any]:
       SCREAMING_SNAKE_CASE__,SCREAMING_SNAKE_CASE__   =   self.model_tester.prepare_config_and_inputs_for_common()
       SCREAMING_SNAKE_CASE__   =   3
       SCREAMING_SNAKE_CASE__   =   '''single_label_classification'''
       SCREAMING_SNAKE_CASE__   =   input_dict['''input_ids''']
       SCREAMING_SNAKE_CASE__   =   input_ids.ne(1 ).to(__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   ids_tensor([self.model_tester.batch_size]     ,       self.model_tester.type_sequence_label_size )
       SCREAMING_SNAKE_CASE__   =   FalconForSequenceClassification(__lowerCamelCase )
       model.to(__lowerCamelCase )
       model.eval()
       SCREAMING_SNAKE_CASE__   =   model(__lowerCamelCase     ,       attention_mask=__lowerCamelCase     ,       labels=__lowerCamelCase )
       self.assertEqual(result.logits.shape     ,       (self.model_tester.batch_size, self.model_tester.num_labels) )






  def 				lowercase_		(							self						:		str )		->							List[Any]:
       SCREAMING_SNAKE_CASE__,SCREAMING_SNAKE_CASE__   =   self.model_tester.prepare_config_and_inputs_for_common()
       SCREAMING_SNAKE_CASE__   =   input_dict['''input_ids''']
       SCREAMING_SNAKE_CASE__   =   FalconForCausalLM(__lowerCamelCase )
       model.to(__lowerCamelCase )
       model.eval()
       SCREAMING_SNAKE_CASE__   =   model(__lowerCamelCase     ,       use_cache=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   input_ids.shape[0]
       SCREAMING_SNAKE_CASE__   =   model._convert_to_rw_cache(result.past_key_values )
       SCREAMING_SNAKE_CASE__   =   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 				lowercase_		(							self						:		str )		->							List[Any]:
       SCREAMING_SNAKE_CASE__,SCREAMING_SNAKE_CASE__   =   self.model_tester.prepare_config_and_inputs_for_common()
       SCREAMING_SNAKE_CASE__   =   3
       SCREAMING_SNAKE_CASE__   =   '''multi_label_classification'''
       SCREAMING_SNAKE_CASE__   =   input_dict['''input_ids''']
       SCREAMING_SNAKE_CASE__   =   input_ids.ne(1 ).to(__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   ids_tensor(
           [self.model_tester.batch_size, config.num_labels]     ,       self.model_tester.type_sequence_label_size ).to(torch.float )
       SCREAMING_SNAKE_CASE__   =   FalconForSequenceClassification(__lowerCamelCase )
       model.to(__lowerCamelCase )
       model.eval()
       SCREAMING_SNAKE_CASE__   =   model(__lowerCamelCase     ,       attention_mask=__lowerCamelCase     ,       labels=__lowerCamelCase )
       self.assertEqual(result.logits.shape     ,       (self.model_tester.batch_size, self.model_tester.num_labels) )







  def 				lowercase_		(							self						:		str )		->							Tuple:
       # Falcon can have different numbers of KV-heads than the number of query heads, so we need
       # to override this test to use the right head counts.
       for model_class in self.all_generative_model_classes:
            SCREAMING_SNAKE_CASE__,SCREAMING_SNAKE_CASE__   =   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

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

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

            SCREAMING_SNAKE_CASE__   =   outputs['''past_key_values''']
            self.assertEqual(len(__lowerCamelCase )     ,       __lowerCamelCase )

            SCREAMING_SNAKE_CASE__,SCREAMING_SNAKE_CASE__   =   inputs['''input_ids'''].shape
            for i in range(__lowerCamelCase ):
                 if config.new_decoder_architecture:
                      SCREAMING_SNAKE_CASE__   =   config.num_attention_heads
                 elif config.multi_query:
                      SCREAMING_SNAKE_CASE__   =   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 	UpperCAmelCase__		(	unittest.TestCase	):






  """simple docstring"""


  @slow
  def 				lowercase_		(							self						:		str )		->							Tuple:
       SCREAMING_SNAKE_CASE__   =   AutoTokenizer.from_pretrained('''Rocketknight1/falcon-rw-1b''' )
       SCREAMING_SNAKE_CASE__   =   FalconForCausalLM.from_pretrained('''Rocketknight1/falcon-rw-1b''' )
       model.eval()
       model.to(__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   tokenizer('''My favorite food is'''     ,       return_tensors='''pt''' ).to(__lowerCamelCase )

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

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

       self.assertEqual(__lowerCamelCase     ,       __lowerCamelCase )






  @slow
  def 				lowercase_		(							self						:		Optional[Any] )		->							Optional[Any]:
       # The big models are way too big for the CI, so we use tiny random models that resemble their
       # architectures but with much smaller and fewer layers
       for repo in ["Rocketknight1/tiny-random-falcon-7b", "Rocketknight1/tiny-random-falcon-40b"]:
            SCREAMING_SNAKE_CASE__   =   AutoTokenizer.from_pretrained(__lowerCamelCase )
            SCREAMING_SNAKE_CASE__   =   FalconForCausalLM.from_pretrained(__lowerCamelCase )
            model.eval()
            model.to(__lowerCamelCase )
            SCREAMING_SNAKE_CASE__   =   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 				lowercase_		(							self						:		Tuple )		->							Optional[Any]:
       # The big models are way too big for the CI, so we use tiny random models that resemble their
       # architectures but with much smaller and fewer layers
       with torch.no_grad():
            for repo in [
                "Rocketknight1/falcon-rw-1b",
                "Rocketknight1/tiny-random-falcon-7b",
                "Rocketknight1/tiny-random-falcon-40b",
            ]:
                 SCREAMING_SNAKE_CASE__   =   AutoTokenizer.from_pretrained(__lowerCamelCase )
                 SCREAMING_SNAKE_CASE__   =   FalconForCausalLM.from_pretrained(__lowerCamelCase )
                 model.eval()
                 model.to(device=__lowerCamelCase )
                 SCREAMING_SNAKE_CASE__   =   tokenizer('''My favorite food is'''     ,       return_tensors='''pt''' ).to(__lowerCamelCase )

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





import datasets

from .evaluate import evaluate


_SCREAMING_SNAKE_CASE					:  Union[str, Any]             =      '''\
@inproceedings{Rajpurkar2016SQuAD10,
  title={SQuAD: 100, 000+ Questions for Machine Comprehension of Text},
  author={Pranav Rajpurkar and Jian Zhang and Konstantin Lopyrev and Percy Liang},
  booktitle={EMNLP},
  year={2016}
}
'''

_SCREAMING_SNAKE_CASE					:  Dict             =      '''
This metric wrap the official scoring script for version 1 of the Stanford Question Answering Dataset (SQuAD).

Stanford Question Answering Dataset (SQuAD) is a reading comprehension dataset, consisting of questions posed by
crowdworkers on a set of Wikipedia articles, where the answer to every question is a segment of text, or span,
from the corresponding reading passage, or the question might be unanswerable.
'''

_SCREAMING_SNAKE_CASE					:  str             =      '''
Computes SQuAD scores (F1 and EM).
Args:
    predictions: List of question-answers dictionaries with the following key-values:
        - \'id\': id of the question-answer pair as given in the references (see below)
        - \'prediction_text\': the text of the answer
    references: List of question-answers dictionaries with the following key-values:
        - \'id\': id of the question-answer pair (see above),
        - \'answers\': a Dict in the SQuAD dataset format
            {
                \'text\': list of possible texts for the answer, as a list of strings
                \'answer_start\': list of start positions for the answer, as a list of ints
            }
            Note that answer_start values are not taken into account to compute the metric.
Returns:
    \'exact_match\': Exact match (the normalized answer exactly match the gold answer)
    \'f1\': The F-score of predicted tokens versus the gold answer
Examples:

    >>> predictions = [{\'prediction_text\': \'1976\', \'id\': \'56e10a3be3433e1400422b22\'}]
    >>> references = [{\'answers\': {\'answer_start\': [97], \'text\': [\'1976\']}, \'id\': \'56e10a3be3433e1400422b22\'}]
    >>> squad_metric = datasets.load_metric("squad")
    >>> results = squad_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {\'exact_match\': 100.0, \'f1\': 100.0}
'''






@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION						,					_KWARGS_DESCRIPTION	)
class 	UpperCAmelCase__		(	datasets.Metric	):






  """simple docstring"""


  def 				lowercase_		(							self						:		List[Any] )		->							Optional[int]:
       return datasets.MetricInfo(
           description=_DESCRIPTION     ,       citation=_CITATION     ,       inputs_description=_KWARGS_DESCRIPTION     ,       features=datasets.Features(
               {
                   '''predictions''': {'''id''': datasets.Value('''string''' ), '''prediction_text''': datasets.Value('''string''' )},
                   '''references''': {
                       '''id''': datasets.Value('''string''' ),
                       '''answers''': datasets.features.Sequence(
                           {
                               '''text''': datasets.Value('''string''' ),
                               '''answer_start''': datasets.Value('''int32''' ),
                           } ),
                   },
               } )     ,       codebase_urls=['''https://rajpurkar.github.io/SQuAD-explorer/''']     ,       reference_urls=['''https://rajpurkar.github.io/SQuAD-explorer/''']     ,       )







  def 				lowercase_		(							self						:		Optional[Any]     ,       __lowerCamelCase						:		Dict     ,       __lowerCamelCase						:		List[Any] )		->							Optional[int]:
       SCREAMING_SNAKE_CASE__   =   {prediction['''id''']: prediction['''prediction_text'''] for prediction in predictions}
       SCREAMING_SNAKE_CASE__   =   [
           {
               '''paragraphs''': [
                   {
                       '''qas''': [
                           {
                               '''answers''': [{'''text''': answer_text} for answer_text in ref['''answers''']['''text''']],
                               '''id''': ref['''id'''],
                           }
                           for ref in references
                       ]
                   }
               ]
           }
       ]
       SCREAMING_SNAKE_CASE__   =   evaluate(dataset=__lowerCamelCase     ,       predictions=__lowerCamelCase )
       return score


