





import re
import tempfile
import unittest
from pathlib import Path

from datasets.utils.metadata import DatasetMetadata







def      A__				(       SCREAMING_SNAKE_CASE__)  ->       str:
  __snake_case:		List[Any]					    =		min(re.search("""^ +"""   ,   SCREAMING_SNAKE_CASE__).end() if t.startswith(""" """) else 0 for t in string.splitlines())
  return "\n".join([line[indent_level:] for line in string.splitlines() if indent_level < len(SCREAMING_SNAKE_CASE__)])


__UpperCAmelCase			:  List[Any]										=				"\\n---\nlanguage:\n- zh\n- en\ntask_ids:\n- sentiment-classification\n---\n# Begin of markdown\n\nSome cool dataset card\n"

__UpperCAmelCase			:  List[str]										=				"\\n---\n---\n# Begin of markdown\n\nSome cool dataset card\n"


__UpperCAmelCase			:  Optional[Any]										=				"\\n# Begin of markdown\n\nSome cool dataset card\n"







class        __snake_case			(				unittest.TestCase     ):





       '''simple docstring'''







       def 				UpperCAmelCase__					(    self					:       Optional[int]						):
         with tempfile.TemporaryDirectory() as tmp_dir:
           __snake_case:		Dict					    =		Path(A						) / """README.md"""
           with open(A				,							"""w+"""						) as readme_file:
             readme_file.write(A						)
           __snake_case:		Dict					    =		DatasetMetadata.from_readme(A						)
           self.assertDictEqual(A				,							{"""language""": ["""zh""", """en"""], """task_ids""": ["""sentiment-classification"""]}						)

           with open(A				,							"""w+"""						) as readme_file:
             readme_file.write(A						)
           __snake_case:		Any					    =		DatasetMetadata.from_readme(A						)
           self.assertDictEqual(A				,							{}						)

           with open(A				,							"""w+"""						) as readme_file:
             readme_file.write(A						)
           __snake_case:		Dict					    =		DatasetMetadata.from_readme(A						)
           self.assertEqual(A				,							{}						)






       def 				UpperCAmelCase__					(    self					:       Optional[Any]						):
         __snake_case:		Tuple					    =		_dedent(
             """\
            annotations_creators:
            - found
            language_creators:
            - found
            language:
            - en
            license:
            - unknown
            multilinguality:
            - monolingual
            pretty_name: Test Dataset
            size_categories:
            - 10K<n<100K
            source_datasets:
            - extended|other-yahoo-webscope-l6
            task_categories:
            - question-answering
            task_ids:
            - open-domain-qa
            """						)
         assert DatasetMetadata.from_yaml_string(A						)

         __snake_case:		Optional[int]					    =		_dedent(
             """\
            annotations_creators:
            - found
            language:
            - en
            license:
            - unknown
            multilinguality:
            - monolingual
            pretty_name: Test Dataset
            size_categories:
            - 10K<n<100K
            source_datasets:
            - extended|other-yahoo-webscope-l6
            task_categories:
            - question-answering
            task_ids:
            - open-domain-qa
            task_ids:
            - open-domain-qa
            """						)
         with self.assertRaises(A						):
           DatasetMetadata.from_yaml_string(A						)

         __snake_case:		List[Any]					    =		_dedent(
             """\
            annotations_creators:
            - found
            language_creators:
            - found
            language:
            - en
            license:
            - unknown
            multilinguality:
            - monolingual
            pretty_name: Test Dataset
            size_categories:
            - 10K<n<100K
            source_datasets:
            - extended|other-yahoo-webscope-l6
            task_categories:
            - text-classification
            task_ids:
            - multi-class-classification
            paperswithcode_id:
            - squad
            configs:
            - en
            train-eval-index:
            - config: en
              task: text-classification
              task_id: multi_class_classification
              splits:
                train_split: train
                eval_split: test
              col_mapping:
                text: text
                label: target
              metrics:
                - type: accuracy
                  name: Accuracy
            extra_gated_prompt: |
              By clicking on “Access repository” below, you also agree to ImageNet Terms of Access:
              [RESEARCHER_FULLNAME] (the \"Researcher\") has requested permission to use the ImageNet database (the \"Database\") at Princeton University and Stanford University. In exchange for such permission, Researcher hereby agrees to the following terms and conditions:
              1. Researcher shall use the Database only for non-commercial research and educational purposes.
            extra_gated_fields:
              Company: text
              Country: text
              I agree to use this model for non-commerical use ONLY: checkbox
            """						)
         assert DatasetMetadata.from_yaml_string(A						)













import unittest

from transformers import FunnelConfig, FunnelTokenizer, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
      import torch

      from transformers import (
          MODEL_FOR_PRETRAINING_MAPPING,
          FunnelBaseModel,
          FunnelForMaskedLM,
          FunnelForMultipleChoice,
          FunnelForPreTraining,
          FunnelForQuestionAnswering,
          FunnelForSequenceClassification,
          FunnelForTokenClassification,
          FunnelModel,
      )







class        __snake_case			:





       '''simple docstring'''







       def __init__(    self					:       str				,							A					:       int				,							A					:       List[Any]=13				,							A					:       Dict=7				,							A					:       Optional[int]=True				,							A					:       Dict=True				,							A					:       str=True				,							A					:       Union[str, Any]=True				,							A					:       Union[str, Any]=99				,							A					:       Dict=[1, 1, 2]				,							A					:       List[Any]=1				,							A					:       List[str]=32				,							A					:       Dict=4				,							A					:       Tuple=8				,							A					:       List[Any]=37				,							A					:       Dict="gelu_new"				,							A					:       Dict=0.1				,							A					:       List[Any]=0.1				,							A					:       Optional[int]=0.0				,							A					:       Tuple=512				,							A					:       Tuple=3				,							A					:       List[str]=0.02				,							A					:       str=3				,							A					:       Optional[Any]=4				,							A					:       str=None				,							A					:       Union[str, Any]=False				,							):
         __snake_case:		int					    =		parent
         __snake_case:		Optional[Any]					    =		batch_size
         __snake_case:		Optional[Any]					    =		seq_length
         __snake_case:		List[Any]					    =		is_training
         __snake_case:		List[str]					    =		use_input_mask
         __snake_case:		Any					    =		use_token_type_ids
         __snake_case:		Union[str, Any]					    =		use_labels
         __snake_case:		Any					    =		vocab_size
         __snake_case:		int					    =		block_sizes
         __snake_case:		Optional[int]					    =		num_decoder_layers
         __snake_case:		Union[str, Any]					    =		d_model
         __snake_case:		List[str]					    =		n_head
         __snake_case:		Optional[Any]					    =		d_head
         __snake_case:		str					    =		d_inner
         __snake_case:		Optional[Any]					    =		hidden_act
         __snake_case:		List[Any]					    =		hidden_dropout
         __snake_case:		List[Any]					    =		attention_dropout
         __snake_case:		Tuple					    =		activation_dropout
         __snake_case:		Optional[int]					    =		max_position_embeddings
         __snake_case:		Optional[int]					    =		type_vocab_size
         __snake_case:		Any					    =		2
         __snake_case:		Dict					    =		num_labels
         __snake_case:		List[Any]					    =		num_choices
         __snake_case:		Any					    =		scope
         __snake_case:		Optional[Any]					    =		initializer_std

         # Used in the tests to check the size of the first attention layer
         __snake_case:		Union[str, Any]					    =		n_head
         # Used in the tests to check the size of the first hidden state
         __snake_case:		Union[str, Any]					    =		self.d_model
         # Used in the tests to check the number of output hidden states/attentions
         __snake_case:		Optional[int]					    =		sum(self.block_sizes						) + (0 if base else self.num_decoder_layers)
         # FunnelModel adds two hidden layers: input embeddings and the sum of the upsampled encoder hidden state with
         # the last hidden state of the first block (which is the first hidden state of the decoder).
         if not base:
           __snake_case:		Any					    =		self.num_hidden_layers + 2




       def 				UpperCAmelCase__					(    self					:       Any						):
         __snake_case:		Tuple					    =		ids_tensor([self.batch_size, self.seq_length]				,							self.vocab_size						)

         __snake_case:		Optional[int]					    =		None
         if self.use_input_mask:
           __snake_case:		Optional[Any]					    =		ids_tensor([self.batch_size, self.seq_length]				,							vocab_size=2						)

         __snake_case:		Dict					    =		None
         if self.use_token_type_ids:
           __snake_case:		List[str]					    =		ids_tensor([self.batch_size, self.seq_length]				,							self.type_vocab_size						)

         __snake_case:		Optional[Any]					    =		None
         __snake_case:		Optional[int]					    =		None
         __snake_case:		Any					    =		None
         if self.use_labels:
           __snake_case:		List[Any]					    =		ids_tensor([self.batch_size]				,							self.type_sequence_label_size						)
           __snake_case:		Any					    =		ids_tensor([self.batch_size, self.seq_length]				,							self.num_labels						)
           __snake_case:		Union[str, Any]					    =		ids_tensor([self.batch_size]				,							self.num_choices						)
           __snake_case:		Tuple					    =		ids_tensor([self.batch_size, self.seq_length]				,							1						)

         __snake_case:		Dict					    =		self.get_config()

         return (
             config,
             input_ids,
             token_type_ids,
             input_mask,
             sequence_labels,
             token_labels,
             choice_labels,
             fake_token_labels,
         )




       def 				UpperCAmelCase__					(    self					:       Dict						):
         return FunnelConfig(
             vocab_size=self.vocab_size				,							block_sizes=self.block_sizes				,							num_decoder_layers=self.num_decoder_layers				,							d_model=self.d_model				,							n_head=self.n_head				,							d_head=self.d_head				,							d_inner=self.d_inner				,							hidden_act=self.hidden_act				,							hidden_dropout=self.hidden_dropout				,							attention_dropout=self.attention_dropout				,							activation_dropout=self.activation_dropout				,							max_position_embeddings=self.max_position_embeddings				,							type_vocab_size=self.type_vocab_size				,							initializer_std=self.initializer_std				,							)




       def 				UpperCAmelCase__					(    self					:       List[Any]				,							A					:       Tuple				,							A					:       Any				,							A					:       int				,							A					:       Optional[Any]				,							A					:       List[str]				,							A					:       Optional[int]				,							A					:       Tuple				,							A					:       Optional[Any]				,							):
         __snake_case:		int					    =		FunnelModel(config=A						)
         model.to(A						)
         model.eval()
         __snake_case:		Union[str, Any]					    =		model(A				,							attention_mask=A				,							token_type_ids=A						)
         __snake_case:		Dict					    =		model(A				,							token_type_ids=A						)
         __snake_case:		Optional[int]					    =		model(A						)
         self.parent.assertEqual(result.last_hidden_state.shape				,							(self.batch_size, self.seq_length, self.d_model)						)

         __snake_case:		Any					    =		False
         __snake_case:		List[Any]					    =		model(A						)
         self.parent.assertEqual(result.last_hidden_state.shape				,							(self.batch_size, self.seq_length, self.d_model)						)

         __snake_case:		List[str]					    =		False
         __snake_case:		Optional[int]					    =		model(A						)
         self.parent.assertEqual(result.last_hidden_state.shape				,							(self.batch_size, self.seq_length, self.d_model)						)




       def 				UpperCAmelCase__					(    self					:       Optional[Any]				,							A					:       Union[str, Any]				,							A					:       str				,							A					:       Any				,							A					:       str				,							A					:       Any				,							A					:       str				,							A					:       List[str]				,							A					:       Dict				,							):
         __snake_case:		Dict					    =		FunnelBaseModel(config=A						)
         model.to(A						)
         model.eval()
         __snake_case:		List[str]					    =		model(A				,							attention_mask=A				,							token_type_ids=A						)
         __snake_case:		Union[str, Any]					    =		model(A				,							token_type_ids=A						)
         __snake_case:		List[Any]					    =		model(A						)
         self.parent.assertEqual(result.last_hidden_state.shape				,							(self.batch_size, 2, self.d_model)						)

         __snake_case:		Optional[Any]					    =		False
         __snake_case:		Tuple					    =		model(A						)
         self.parent.assertEqual(result.last_hidden_state.shape				,							(self.batch_size, 3, self.d_model)						)

         __snake_case:		Union[str, Any]					    =		False
         __snake_case:		List[Any]					    =		model(A						)
         self.parent.assertEqual(result.last_hidden_state.shape				,							(self.batch_size, 2, self.d_model)						)




       def 				UpperCAmelCase__					(    self					:       Tuple				,							A					:       Union[str, Any]				,							A					:       Optional[int]				,							A					:       Optional[int]				,							A					:       Any				,							A					:       str				,							A					:       Optional[int]				,							A					:       Dict				,							A					:       str				,							):
         __snake_case:		Optional[int]					    =		self.num_labels
         __snake_case:		Optional[Any]					    =		FunnelForPreTraining(config=A						)
         model.to(A						)
         model.eval()
         __snake_case:		Dict					    =		model(A				,							attention_mask=A				,							token_type_ids=A				,							labels=A						)
         self.parent.assertEqual(result.logits.shape				,							(self.batch_size, self.seq_length)						)




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




       def 				UpperCAmelCase__					(    self					:       Dict				,							A					:       str				,							A					:       Dict				,							A					:       List[str]				,							A					:       Any				,							A					:       Optional[Any]				,							A					:       Optional[Any]				,							A					:       Optional[Any]				,							A					:       Any				,							):
         __snake_case:		Dict					    =		self.num_labels
         __snake_case:		Dict					    =		FunnelForSequenceClassification(A						)
         model.to(A						)
         model.eval()
         __snake_case:		str					    =		model(A				,							attention_mask=A				,							token_type_ids=A				,							labels=A						)
         self.parent.assertEqual(result.logits.shape				,							(self.batch_size, self.num_labels)						)




       def 				UpperCAmelCase__					(    self					:       List[str]				,							A					:       Optional[int]				,							A					:       str				,							A					:       Optional[int]				,							A					:       str				,							A					:       Tuple				,							A					:       int				,							A					:       int				,							A					:       Dict				,							):
         __snake_case:		List[Any]					    =		self.num_choices
         __snake_case:		Optional[Any]					    =		FunnelForMultipleChoice(config=A						)
         model.to(A						)
         model.eval()
         __snake_case:		int					    =		input_ids.unsqueeze(1						).expand(-1				,							self.num_choices				,							-1						).contiguous()
         __snake_case:		Tuple					    =		token_type_ids.unsqueeze(1						).expand(-1				,							self.num_choices				,							-1						).contiguous()
         __snake_case:		List[str]					    =		input_mask.unsqueeze(1						).expand(-1				,							self.num_choices				,							-1						).contiguous()
         __snake_case:		Tuple					    =		model(
             A				,							attention_mask=A				,							token_type_ids=A				,							labels=A				,							)
         self.parent.assertEqual(result.logits.shape				,							(self.batch_size, self.num_choices)						)




       def 				UpperCAmelCase__					(    self					:       List[Any]				,							A					:       Optional[int]				,							A					:       str				,							A					:       Union[str, Any]				,							A					:       Optional[int]				,							A					:       Union[str, Any]				,							A					:       Optional[int]				,							A					:       Union[str, Any]				,							A					:       Union[str, Any]				,							):
         __snake_case:		Dict					    =		self.num_labels
         __snake_case:		List[Any]					    =		FunnelForTokenClassification(config=A						)
         model.to(A						)
         model.eval()
         __snake_case:		Tuple					    =		model(A				,							attention_mask=A				,							token_type_ids=A				,							labels=A						)
         self.parent.assertEqual(result.logits.shape				,							(self.batch_size, self.seq_length, self.num_labels)						)




       def 				UpperCAmelCase__					(    self					:       Dict				,							A					:       Optional[Any]				,							A					:       int				,							A					:       Dict				,							A					:       Optional[int]				,							A					:       Tuple				,							A					:       str				,							A					:       List[Any]				,							A					:       Optional[Any]				,							):
         __snake_case:		List[str]					    =		FunnelForQuestionAnswering(config=A						)
         model.to(A						)
         model.eval()
         __snake_case:		str					    =		model(
             A				,							attention_mask=A				,							token_type_ids=A				,							start_positions=A				,							end_positions=A				,							)
         self.parent.assertEqual(result.start_logits.shape				,							(self.batch_size, self.seq_length)						)
         self.parent.assertEqual(result.end_logits.shape				,							(self.batch_size, self.seq_length)						)






       def 				UpperCAmelCase__					(    self					:       str						):
         __snake_case:		Optional[int]					    =		self.prepare_config_and_inputs()
         (
             (
             __snake_case
         )    ,  (
             __snake_case
         )    ,  (
             __snake_case
         )    ,  (
             __snake_case
         )    ,  (
             __snake_case
         )    ,  (
             __snake_case
         )    ,  (
             __snake_case
         )    ,  (
             __snake_case
         )    ,  
         ):		Dict					    =		config_and_inputs
         __snake_case:		Union[str, Any]					    =		{"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
         return config, inputs_dict







@require_torch
class        __snake_case			(				__lowerCamelCase  ,     __lowerCamelCase  ,     unittest.TestCase     ):





       '''simple docstring'''







       lowerCAmelCase__ 						=	False
       lowerCAmelCase__ 						=	False
       lowerCAmelCase__ 						=	(
           (
               FunnelModel,
               FunnelForMaskedLM,
               FunnelForPreTraining,
               FunnelForQuestionAnswering,
               FunnelForTokenClassification,
           )
           if is_torch_available()
           else ()
       )
       lowerCAmelCase__ 						=	(
           {
               """feature-extraction""": (FunnelBaseModel, FunnelModel),
               """fill-mask""": FunnelForMaskedLM,
               """question-answering""": FunnelForQuestionAnswering,
               """text-classification""": FunnelForSequenceClassification,
               """token-classification""": FunnelForTokenClassification,
               """zero-shot""": FunnelForSequenceClassification,
           }
           if is_torch_available()
           else {}
       )




       def 				UpperCAmelCase__					(    self					:       int				,							A					:       Optional[Any]				,							A					:       List[str]				,							A					:       int=False						):
         __snake_case:		str					    =		super()._prepare_for_class(A				,							A				,							return_labels=A						)

         if return_labels:
           if model_class in get_values(A						):
             __snake_case:		str					    =		torch.zeros(
                 (self.model_tester.batch_size, self.model_tester.seq_length)				,							dtype=torch.long				,							device=A						)
         return inputs_dict




       def 				UpperCAmelCase__					(    self					:       List[str]						):
         __snake_case:		Union[str, Any]					    =		FunnelModelTester(self						)
         __snake_case:		List[str]					    =		ConfigTester(self				,							config_class=A						)




       def 				UpperCAmelCase__					(    self					:       Dict						):
         self.config_tester.run_common_tests()




       def 				UpperCAmelCase__					(    self					:       Optional[Any]						):
         __snake_case:		int					    =		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*A						)




       def 				UpperCAmelCase__					(    self					:       Optional[int]						):
         __snake_case:		Optional[int]					    =		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_pretraining(*A						)




       def 				UpperCAmelCase__					(    self					:       str						):
         __snake_case:		Optional[int]					    =		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_lm(*A						)




       def 				UpperCAmelCase__					(    self					:       Optional[int]						):
         __snake_case:		Any					    =		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(*A						)




       def 				UpperCAmelCase__					(    self					:       str						):
         __snake_case:		str					    =		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_question_answering(*A						)






       def 				UpperCAmelCase__					(    self					:       Union[str, Any]				,							A					:       List[Any]						):
         if hasattr(A				,							"""weight"""						) and module.weight is not None:
           module.weight.data.fill_(3						)
         if hasattr(A				,							"""bias"""						) and module.bias is not None:
           module.bias.data.fill_(3						)

         for param in ["r_w_bias", "r_r_bias", "r_kernel", "r_s_bias", "seg_embed"]:
           if hasattr(A				,							A						) and getattr(A				,							A						) is not None:
             __snake_case:		str					    =		getattr(A				,							A						)
             weight.data.fill_(3						)







@require_torch
class        __snake_case			(				__lowerCamelCase  ,     unittest.TestCase     ):





       '''simple docstring'''







       lowerCAmelCase__ 						=	False
       lowerCAmelCase__ 						=	False
       lowerCAmelCase__ 						=	(
           (FunnelBaseModel, FunnelForMultipleChoice, FunnelForSequenceClassification) if is_torch_available() else ()
       )




       def 				UpperCAmelCase__					(    self					:       Any						):
         __snake_case:		Optional[int]					    =		FunnelModelTester(self				,							base=A						)
         __snake_case:		int					    =		ConfigTester(self				,							config_class=A						)




       def 				UpperCAmelCase__					(    self					:       Dict						):
         self.config_tester.run_common_tests()




       def 				UpperCAmelCase__					(    self					:       Optional[int]						):
         __snake_case:		List[str]					    =		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_base_model(*A						)




       def 				UpperCAmelCase__					(    self					:       str						):
         __snake_case:		Dict					    =		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_sequence_classification(*A						)




       def 				UpperCAmelCase__					(    self					:       Optional[Any]						):
         __snake_case:		List[str]					    =		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_multiple_choice(*A						)




       def 				UpperCAmelCase__					(    self					:       Optional[Any]						):
         __snake_case    ,  __snake_case:		Optional[Any]					    =		self.model_tester.prepare_config_and_inputs_for_common()
         __snake_case:		List[str]					    =		True

         for model_class in self.all_model_classes:
           if model_class.__name__ == "FunnelBaseModel":
             continue
           __snake_case:		List[Any]					    =		model_class(A						)
           model.to(A						)
           model.train()
           __snake_case:		Optional[int]					    =		self._prepare_for_class(A				,							A				,							return_labels=A						)
           __snake_case:		Optional[int]					    =		model(**A						).loss
           loss.backward()






       def 				UpperCAmelCase__					(    self					:       Union[str, Any]				,							A					:       Optional[Any]						):
         if hasattr(A				,							"""weight"""						) and module.weight is not None:
           module.weight.data.fill_(3						)
         if hasattr(A				,							"""bias"""						) and module.bias is not None:
           module.bias.data.fill_(3						)

         for param in ["r_w_bias", "r_r_bias", "r_kernel", "r_s_bias", "seg_embed"]:
           if hasattr(A				,							A						) and getattr(A				,							A						) is not None:
             __snake_case:		int					    =		getattr(A				,							A						)
             weight.data.fill_(3						)







@require_torch
@require_sentencepiece
@require_tokenizers
class        __snake_case			(				unittest.TestCase     ):





       '''simple docstring'''







       def 				UpperCAmelCase__					(    self					:       str						):
         __snake_case:		List[str]					    =		13
         __snake_case:		List[Any]					    =		7
         __snake_case:		List[Any]					    =		torch.arange(0				,							batch_size * sequence_length						).long().reshape(A				,							A						)
         __snake_case:		Tuple					    =		[0, 1, 2, 3, 4, 5, 6, 4, 1, 3, 5, 0, 1]
         __snake_case:		List[str]					    =		torch.tensor([[2] + [0] * a + [1] * (sequence_length - a - 1) for a in lengths]						)

         __snake_case:		Optional[int]					    =		FunnelModel.from_pretrained("""sgugger/funnel-random-tiny"""						)
         __snake_case:		List[Any]					    =		model(A				,							token_type_ids=A						)[0].abs()

         __snake_case:		str					    =		torch.tensor(2344.8352						)
         __snake_case:		Union[str, Any]					    =		torch.tensor(0.8052						)
         self.assertTrue(torch.allclose(output.sum()				,							A				,							atol=1E-4						)						)
         self.assertTrue(torch.allclose(output.mean()				,							A				,							atol=1E-4						)						)

         __snake_case:		str					    =		torch.tensor([[1] * 7, [1] * 4 + [0] * 3] * 6 + [[0, 1, 1, 0, 0, 1, 1]]						)
         __snake_case:		Tuple					    =		model(A				,							attention_mask=A				,							token_type_ids=A						)[0].abs()

         __snake_case:		List[str]					    =		torch.tensor(2343.8425						)
         __snake_case:		List[Any]					    =		torch.tensor(0.8049						)
         self.assertTrue(torch.allclose(output.sum()				,							A				,							atol=1E-4						)						)
         self.assertTrue(torch.allclose(output.mean()				,							A				,							atol=1E-4						)						)






       @slow
       def 				UpperCAmelCase__					(    self					:       Optional[Any]						):
         __snake_case:		Union[str, Any]					    =		FunnelTokenizer.from_pretrained("""huggingface/funnel-small"""						)
         __snake_case:		Tuple					    =		FunnelModel.from_pretrained("""huggingface/funnel-small"""						)
         __snake_case:		Tuple					    =		tokenizer("""Hello! I am the Funnel Transformer model."""				,							return_tensors="""pt"""						)
         __snake_case:		Union[str, Any]					    =		model(**A						)[0]

         __snake_case:		int					    =		torch.tensor(235.7246						)
         __snake_case:		Dict					    =		torch.tensor(0.0256						)
         self.assertTrue(torch.allclose(output.sum()				,							A				,							atol=1E-4						)						)
         self.assertTrue(torch.allclose(output.mean()				,							A				,							atol=1E-4						)						)






