


import doctest
import glob
import importlib
import inspect
import os
import re
from contextlib import contextmanager
from functools import wraps
from unittest.mock import patch

import numpy as np
import pytest
from absl.testing import parameterized

import datasets
from datasets import load_metric

from .utils import for_all_test_methods, local, slow


# mark all tests as integration
__snake_case   							=						pytest.mark.integration


__snake_case   							=						{'''comet'''}
__snake_case   							=						importlib.util.find_spec('''fairseq''') is not None

__snake_case   							=						{'''code_eval'''}
__snake_case   							=						os.name == '''nt'''

__snake_case   							=						{'''bertscore''', '''frugalscore''', '''perplexity'''}
__snake_case   							=						importlib.util.find_spec('''transformers''') is not None






def 		_A		(		_lowercase )					-> Optional[Any]:


     """simple docstring"""


     @wraps(_lowercase )
     def wrapper(self					,  _lowercase ):
          if not _has_fairseq and metric_name in REQUIRE_FAIRSEQ:
               self.skipTest('"test requires Fairseq"' )
          else:
               test_case(self					,  _lowercase )

     return wrapper






def 		_A		(		_lowercase )					-> List[str]:


     """simple docstring"""


     @wraps(_lowercase )
     def wrapper(self					,  _lowercase ):
          if not _has_transformers and metric_name in REQUIRE_TRANSFORMERS:
               self.skipTest('"test requires transformers"' )
          else:
               test_case(self					,  _lowercase )

     return wrapper






def 		_A		(		_lowercase )					-> List[str]:


     """simple docstring"""


     @wraps(_lowercase )
     def wrapper(self					,  _lowercase ):
          if _on_windows and metric_name in UNSUPPORTED_ON_WINDOWS:
               self.skipTest('"test not supported on Windows"' )
          else:
               test_case(self					,  _lowercase )

     return wrapper






def 		_A		(		)					-> List[str]:


     """simple docstring"""


     __UpperCamelCase =			[metric_dir.split(os.sep )[-2] for metric_dir in glob.glob('./metrics/*/' )]
     return [{"testcase_name": x, "metric_name": x} for x in metrics if x != "gleu"]  # gleu is unfinished



@parameterized.named_parameters(get_local_metric_names()						)
@for_all_test_methods(
    _a				,      _a				,      _a						)
@local
class 	__lowerCamelCase			(parameterized.TestCase						):
       _lowercase											=     {}
       _lowercase											=     None







       @pytest.mark.filterwarnings('ignore:metric_module_factory is deprecated:FutureWarning'					)
       @pytest.mark.filterwarnings('ignore:load_metric is deprecated:FutureWarning'					)
       def 		snake_case_	(			self: int,A_: List[Any]					):






            '''simple docstring'''




            __UpperCamelCase =			'[...]'
            __UpperCamelCase =			importlib.import_module(
                datasets.load.metric_module_factory(os.path.join('metrics',A_					)					).module_path					)
            __UpperCamelCase =			datasets.load.import_main_class(metric_module.__name__,dataset=A_					)
            # check parameters
            __UpperCamelCase =			inspect.signature(metric._compute					).parameters
            self.assertTrue(all(p.kind != p.VAR_KEYWORD for p in parameters.values()					)					)  # no **kwargs
            # run doctest
            with self.patch_intensive_calls(A_,metric_module.__name__					):
                 with self.use_local_metrics():
                      try:
                           __UpperCamelCase =			doctest.testmod(A_,verbose=A_,raise_on_error=A_					)
                      except doctest.UnexpectedException as e:
                           raise e.exc_info[1]  # raise the exception that doctest caught
            self.assertEqual(results.failed,0					)
            self.assertGreater(results.attempted,1					)







       @slow
       def 		snake_case_	(			self: Optional[Any],A_: List[str]					):






            '''simple docstring'''




            __UpperCamelCase =			'[...]'
            __UpperCamelCase =			importlib.import_module(
                datasets.load.metric_module_factory(os.path.join('metrics',A_					)					).module_path					)
            # run doctest
            with self.use_local_metrics():
                 __UpperCamelCase =			doctest.testmod(A_,verbose=A_,raise_on_error=A_					)
            self.assertEqual(results.failed,0					)
            self.assertGreater(results.attempted,1					)







       @contextmanager
       def 		snake_case_	(			self: Dict,A_: Optional[Any],A_: Any					):






            '''simple docstring'''




            if metric_name in self.INTENSIVE_CALLS_PATCHER:
                 with self.INTENSIVE_CALLS_PATCHER[metric_name](A_					):
                      yield
            else:
                 yield







       @contextmanager
       def 		snake_case_	(			self: Tuple					):






            '''simple docstring'''




            def load_local_metric(A_: List[Any],*A_: str,**A_: List[Any]					):
                 return load_metric(os.path.join('metrics',A_					),*A_,**A_					)

            with patch('datasets.load_metric'					) as mock_load_metric:
                 __UpperCamelCase =			load_local_metric
                 yield







       @classmethod
       def 		snake_case_	(			cls: Any,A_: str					):






            '''simple docstring'''




            def wrapper(A_: Optional[Any]					):
                 __UpperCamelCase =			contextmanager(A_					)
                 __UpperCamelCase =			patcher
                 return patcher

            return wrapper






@LocalMetricTest.register_intensive_calls_patcher('bleurt' )
def 		_A		(		_lowercase )					-> Optional[Any]:


     """simple docstring"""


     import tensorflow.compat.va as tf
     from bleurt.score import Predictor

     tf.flags.DEFINE_string('sv'					,  ''					,  '' )  # handle pytest cli flags



     class 	__lowerCamelCase			(_a						):







            def 		snake_case_	(			self: List[str],A_: List[Any]					):






                 '''simple docstring'''




                 assert len(input_dict['input_ids']					) == 2
                 return np.array([1.0_3, 1.0_4]					)

    # mock predict_fn which is supposed to do a forward pass with a bleurt model
     with patch('bleurt.score._create_predictor' ) as mock_create_predictor:
          __UpperCamelCase =			MockedPredictor()
          yield






@LocalMetricTest.register_intensive_calls_patcher('bertscore' )
def 		_A		(		_lowercase )					-> Union[str, Any]:


     """simple docstring"""


     import torch

     def bert_cos_score_idf(_lowercase					,  _lowercase					,  *_lowercase					,  **_lowercase ):
          return torch.tensor([[1.0, 1.0, 1.0]] * len(_lowercase ) )

     # mock get_model which is supposed to do download a bert model
     # mock bert_cos_score_idf which is supposed to do a forward pass with a bert model
     with patch('bert_score.scorer.get_model' ), patch(
         'bert_score.scorer.bert_cos_score_idf' ) as mock_bert_cos_score_idf:
          __UpperCamelCase =			bert_cos_score_idf
          yield






@LocalMetricTest.register_intensive_calls_patcher('comet' )
def 		_A		(		_lowercase )					-> Optional[Any]:


     """simple docstring"""


     def load_from_checkpoint(_lowercase ):



          class 	__lowerCamelCase			:







                 def 		snake_case_	(			self: Optional[int],A_: int,*A_: Optional[int],**A_: List[str]					):






                      '''simple docstring'''




                      assert len(A_					) == 2
                      __UpperCamelCase =			[0.1_9, 0.9_2]
                      return scores, sum(A_					) / len(A_					)



          return Model()

     # mock load_from_checkpoint which is supposed to do download a bert model
     # mock load_from_checkpoint which is supposed to do download a bert model
     with patch('comet.download_model' ) as mock_download_model:
          __UpperCamelCase =			None
          with patch('comet.load_from_checkpoint' ) as mock_load_from_checkpoint:
               __UpperCamelCase =			load_from_checkpoint
               yield






def 		_A		(		)					-> Union[str, Any]:


     """simple docstring"""


     __UpperCamelCase =			load_metric(os.path.join('metrics'					,  'seqeval' ) )
     __UpperCamelCase =			'ERROR'
     __UpperCamelCase =			f'''Scheme should be one of [IOB1, IOB2, IOE1, IOE2, IOBES, BILOU], got {wrong_scheme}'''
     with pytest.raises(_lowercase					,  match=re.escape(_lowercase ) ):
          metric.compute(predictions=[]					,  references=[]					,  scheme=_lowercase )








"""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        __magic_name__				:






				'''simple docstring'''





				def __init__(			self						,					_a						,					_a=3						,					_a=7						,					_a=True						,					_a=True						,					_a=False						,					_a=True						,					_a=99						,					_a=32						,					_a=5						,					_a=4						,					_a=37						,					_a="gelu"						,					_a=0.1						,					_a=0.1						,					_a=512						,					_a=16						,					_a=2						,					_a=0.02						,					_a=3						,					_a=4						,					_a=None						,					):





							"""simple docstring"""
							lowerCamelCase      =   parent
							lowerCamelCase      =   batch_size
							lowerCamelCase      =   seq_length
							lowerCamelCase      =   is_training
							lowerCamelCase      =   use_input_mask
							lowerCamelCase      =   use_token_type_ids
							lowerCamelCase      =   use_labels
							lowerCamelCase      =   vocab_size
							lowerCamelCase      =   hidden_size
							lowerCamelCase      =   num_hidden_layers
							lowerCamelCase      =   num_attention_heads
							lowerCamelCase      =   intermediate_size
							lowerCamelCase      =   hidden_act
							lowerCamelCase      =   hidden_dropout_prob
							lowerCamelCase      =   attention_probs_dropout_prob
							lowerCamelCase      =   max_position_embeddings
							lowerCamelCase      =   type_vocab_size
							lowerCamelCase      =   type_sequence_label_size
							lowerCamelCase      =   initializer_range
							lowerCamelCase      =   num_labels
							lowerCamelCase      =   num_choices
							lowerCamelCase      =   scope





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   ids_tensor([self.batch_size, self.seq_length]						,					self.vocab_size					)

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

							lowerCamelCase      =   None

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

							lowerCamelCase      =   self.get_config()

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





				def   _lowerCAmelCase							(			self					):





							"""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=_a						,					initializer_range=self.initializer_range						,					pad_token_id=1						,					new_decoder_architecture=_a						,					)





				def   _lowerCAmelCase							(			self						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a					):





							"""simple docstring"""
							lowerCamelCase      =   FalconModel(config=_a					)
							model.to(_a					)
							model.eval()
							lowerCamelCase      =   model(_a						,					attention_mask=_a					)
							lowerCamelCase      =   model(_a					)
							self.parent.assertEqual(result.last_hidden_state.shape						,					(self.batch_size, self.seq_length, self.hidden_size)					)





				def   _lowerCAmelCase							(			self						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					):





							"""simple docstring"""
							lowerCamelCase      =   True
							lowerCamelCase      =   FalconModel(_a					)
							model.to(_a					)
							model.eval()
							lowerCamelCase      =   model(
							    _a						,					attention_mask=_a						,					encoder_hidden_states=_a						,					encoder_attention_mask=_a						,					)
							lowerCamelCase      =   model(
							    _a						,					attention_mask=_a						,					encoder_hidden_states=_a						,					)
							lowerCamelCase      =   model(_a						,					attention_mask=_a					)
							self.parent.assertEqual(result.last_hidden_state.shape						,					(self.batch_size, self.seq_length, self.hidden_size)					)





				def   _lowerCAmelCase							(			self						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					):





							"""simple docstring"""
							lowerCamelCase      =   FalconForCausalLM(config=_a					)
							model.to(_a					)
							model.eval()
							lowerCamelCase      =   model(_a						,					attention_mask=_a						,					labels=_a					)
							self.parent.assertEqual(result.logits.shape						,					(self.batch_size, self.seq_length, self.vocab_size)					)





				def   _lowerCAmelCase							(			self						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					_a						,					):





							"""simple docstring"""
							lowerCamelCase      =   True
							lowerCamelCase      =   True
							lowerCamelCase      =   FalconForCausalLM(config=_a					)
							model.to(_a					)
							model.eval()

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

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

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

							lowerCamelCase      =   model(
							    _a						,					attention_mask=_a						,					encoder_hidden_states=_a						,					encoder_attention_mask=_a						,					output_hidden_states=_a						,					)["""hidden_states"""][0]
							lowerCamelCase      =   model(
							    _a						,					attention_mask=_a						,					encoder_hidden_states=_a						,					encoder_attention_mask=_a						,					past_key_values=_a						,					output_hidden_states=_a						,					)["""hidden_states"""][0]

							# select random slice
							lowerCamelCase      =   ids_tensor((1,)						,					output_from_past.shape[-1]					).item()
							lowerCamelCase      =   output_from_no_past[:, -3:, random_slice_idx].detach()
							lowerCamelCase      =   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(_a						,					_a						,					atol=1e-3					)					)





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   self.prepare_config_and_inputs()
							(
							    (
							    lowerCamelCase
							) ,  (
							    lowerCamelCase
							) ,  (
							    lowerCamelCase
							) ,  (
							    lowerCamelCase
							) ,  (
							    lowerCamelCase
							) ,  (
							    lowerCamelCase
							) ,  (
							    lowerCamelCase
							) ,  
							)      =   config_and_inputs
							lowerCamelCase      =   {"""input_ids""": input_ids, """attention_mask""": input_mask}
							return config, inputs_dict






@require_torch
class        __magic_name__				(			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   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   FalconModelTester(self					)
							lowerCamelCase      =   ConfigTester(self						,					config_class=_a						,					hidden_size=37					)





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							self.config_tester.run_common_tests()





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*_a					)





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase ,  *lowerCamelCase      =   self.model_tester.prepare_config_and_inputs()
							for alibi in [True, False]:
										lowerCamelCase      =   alibi
										self.model_tester.create_and_check_model(_a						,					*_a					)





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase ,  lowerCamelCase      =   self.model_tester.prepare_config_and_inputs_for_common()
							lowerCamelCase      =   3
							lowerCamelCase      =   input_dict["""input_ids"""]
							lowerCamelCase      =   input_ids.ne(1					).to(_a					)
							lowerCamelCase      =   ids_tensor([self.model_tester.batch_size]						,					self.model_tester.type_sequence_label_size					)
							lowerCamelCase      =   FalconForSequenceClassification(_a					)
							model.to(_a					)
							model.eval()
							lowerCamelCase      =   model(_a						,					attention_mask=_a						,					labels=_a					)
							self.assertEqual(result.logits.shape						,					(self.model_tester.batch_size, self.model_tester.num_labels)					)





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase ,  lowerCamelCase      =   self.model_tester.prepare_config_and_inputs_for_common()
							lowerCamelCase      =   3
							lowerCamelCase      =   """single_label_classification"""
							lowerCamelCase      =   input_dict["""input_ids"""]
							lowerCamelCase      =   input_ids.ne(1					).to(_a					)
							lowerCamelCase      =   ids_tensor([self.model_tester.batch_size]						,					self.model_tester.type_sequence_label_size					)
							lowerCamelCase      =   FalconForSequenceClassification(_a					)
							model.to(_a					)
							model.eval()
							lowerCamelCase      =   model(_a						,					attention_mask=_a						,					labels=_a					)
							self.assertEqual(result.logits.shape						,					(self.model_tester.batch_size, self.model_tester.num_labels)					)





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase ,  lowerCamelCase      =   self.model_tester.prepare_config_and_inputs_for_common()
							lowerCamelCase      =   input_dict["""input_ids"""]
							lowerCamelCase      =   FalconForCausalLM(_a					)
							model.to(_a					)
							model.eval()
							lowerCamelCase      =   model(_a						,					use_cache=_a					)
							lowerCamelCase      =   input_ids.shape[0]
							lowerCamelCase      =   model._convert_to_rw_cache(result.past_key_values					)
							lowerCamelCase      =   model._convert_cache_to_standard_format(_a						,					_a					)
							for layer in range(len(_a					)					):
										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					):





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





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							# 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:
										lowerCamelCase ,  lowerCamelCase      =   self.model_tester.prepare_config_and_inputs_for_common()

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

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

										# 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

										lowerCamelCase      =   (
										    getattr(_a						,					"""decoder_layers"""						,					_a					)
										    or getattr(_a						,					"""num_decoder_layers"""						,					_a					)
										    or config.num_hidden_layers
										)
										lowerCamelCase      =   getattr(_a						,					"""num_kv_heads"""						,					config.num_attention_heads					)
										lowerCamelCase      =   getattr(_a						,					"""d_model"""						,					config.hidden_size					)
										lowerCamelCase      =   embed_dim // num_attention_heads

										lowerCamelCase      =   outputs["""past_key_values"""]
										self.assertEqual(len(_a					)						,					_a					)

										lowerCamelCase ,  lowerCamelCase      =   inputs["""input_ids"""].shape
										for i in range(_a					):
													if config.new_decoder_architecture:
																lowerCamelCase      =   config.num_attention_heads
													elif config.multi_query:
																lowerCamelCase      =   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        __magic_name__				(			unittest.TestCase							):






				'''simple docstring'''





				@slow
				def   _lowerCAmelCase							(			self					):





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

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

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

							self.assertEqual(_a						,					_a					)





				@slow
				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							# 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"]:
										lowerCamelCase      =   AutoTokenizer.from_pretrained(_a					)
										lowerCamelCase      =   FalconForCausalLM.from_pretrained(_a					)
										model.eval()
										model.to(_a					)
										lowerCamelCase      =   tokenizer("""My favorite food is"""						,					return_tensors="""pt"""					).to(_a					)

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





				@slow
				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							# 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",
										]:
													lowerCamelCase      =   AutoTokenizer.from_pretrained(_a					)
													lowerCamelCase      =   FalconForCausalLM.from_pretrained(_a					)
													model.eval()
													model.to(device=_a					)
													lowerCamelCase      =   tokenizer("""My favorite food is"""						,					return_tensors="""pt"""					).to(_a					)

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



