code: 
  
  
  
  '''simple docstring'''
  
  
  
  import subprocess
  import sys
  import warnings
  from argparse import ArgumentParser
  from pathlib import Path
  
  from packaging import version
  
  from .. import AutoFeatureExtractor, AutoImageProcessor, AutoProcessor, AutoTokenizer
  from ..utils import logging
  from ..utils.import_utils import is_optimum_available
  from .convert import export, validate_model_outputs
  from .features import FeaturesManager
  from .utils import get_preprocessor
  
  
  a__						:			List[str]										=			'1.5.0'
  
  a__						:			Union[str, Any]										=			['vision-encoder-decoder']
  
  
  
  
  
  
  
  def _lowercase   (  __A       ):
  
  
  
   '''simple docstring'''
  
  
  
   if is_optimum_available():
    from optimum.version import __version__ as optimum_version
  
    __UpperCamelCase				      =  version.parse(__A       )
    if parsed_optimum_version < version.parse(__A       ):
     raise RuntimeError(
         f"transformers.onnx requires optimum >= {MIN_OPTIMUM_VERSION} but {optimum_version} is installed. You "
         """can upgrade optimum by running: pip install -U optimum[exporters]"""       )
   else:
    raise RuntimeError(
        """transformers.onnx requires optimum to run, you can install the library by running: pip install """
        """optimum[exporters]"""       )
   __UpperCamelCase				      =  [
       sys.executable,
       """-m""",
       """optimum.exporters.onnx""",
       f"--model {args.model}",
       f"--task {args.feature}",
       f"--framework {args.framework}" if args.framework is not None else """""",
       f"{args.output}",
   ]
   __UpperCamelCase				      =  subprocess.Popen(""" """.join(__A       )							,stdout=subprocess.PIPE							,shell=__A       )
   proc.wait()
  
   logger.info(
       """The export was done by optimum.exporters.onnx. We recommend using to use this package directly in future, as """
       """transformers.onnx is deprecated, and will be removed in v5. You can find more information here: """
       """https://huggingface.co/docs/optimum/exporters/onnx/usage_guides/export_a_model."""       )
  
  
  
  
  
  
  
  def _lowercase   (  __A       ):
  
  
  
   '''simple docstring'''
  
  
  
   __UpperCamelCase				      =  args.output if args.output.is_file() else args.output.joinpath("""model.onnx"""       )
   if not args.output.parent.exists():
    args.output.parent.mkdir(parents=__A       )
  
   # Allocate the model
   __UpperCamelCase				      =  FeaturesManager.get_model_from_feature(
       args.feature							,args.model							,framework=args.framework							,cache_dir=args.cache_dir       )
  
   __UpperCamelCase      ,		__UpperCamelCase				      =  FeaturesManager.check_supported_model_or_raise(__A							,feature=args.feature       )
   __UpperCamelCase				      =  model_onnx_config(model.config       )
  
   if model_kind in ENCODER_DECODER_MODELS:
    __UpperCamelCase				      =  model.get_encoder()
    __UpperCamelCase				      =  model.get_decoder()
  
    __UpperCamelCase				      =  onnx_config.get_encoder_config(encoder_model.config       )
    __UpperCamelCase				      =  onnx_config.get_decoder_config(
        encoder_model.config							,decoder_model.config							,feature=args.feature       )
  
    if args.opset is None:
     __UpperCamelCase				      =  max(encoder_onnx_config.default_onnx_opset							,decoder_onnx_config.default_onnx_opset       )
  
    if args.opset < min(encoder_onnx_config.default_onnx_opset							,decoder_onnx_config.default_onnx_opset       ):
     raise ValueError(
         f"Opset {args.opset} is not sufficient to export {model_kind}. At least "
         f" {min(encoder_onnx_config.default_onnx_opset							,decoder_onnx_config.default_onnx_opset       )} is required."       )
  
    __UpperCamelCase				      =  AutoFeatureExtractor.from_pretrained(args.model       )
  
    __UpperCamelCase      ,		__UpperCamelCase				      =  export(
        __A							,__A							,__A							,args.opset							,args.output.parent.joinpath("""encoder_model.onnx"""       )							,)
  
    validate_model_outputs(
        __A							,__A							,__A							,args.output.parent.joinpath("""encoder_model.onnx"""       )							,__A							,args.atol if args.atol else encoder_onnx_config.atol_for_validation							,)
  
    __UpperCamelCase				      =  AutoTokenizer.from_pretrained(args.model       )
  
    __UpperCamelCase      ,		__UpperCamelCase				      =  export(
        __A							,__A							,__A							,args.opset							,args.output.parent.joinpath("""decoder_model.onnx"""       )							,)
  
    validate_model_outputs(
        __A							,__A							,__A							,args.output.parent.joinpath("""decoder_model.onnx"""       )							,__A							,args.atol if args.atol else decoder_onnx_config.atol_for_validation							,)
    logger.info(
        f"All good, model saved at: {args.output.parent.joinpath('encoder_model.onnx'       ).as_posix()},"
        f" {args.output.parent.joinpath('decoder_model.onnx'       ).as_posix()}"       )
  
   else:
    # Instantiate the appropriate preprocessor
    if args.preprocessor == "auto":
     __UpperCamelCase				      =  get_preprocessor(args.model       )
    elif args.preprocessor == "tokenizer":
     __UpperCamelCase				      =  AutoTokenizer.from_pretrained(args.model       )
    elif args.preprocessor == "image_processor":
     __UpperCamelCase				      =  AutoImageProcessor.from_pretrained(args.model       )
    elif args.preprocessor == "feature_extractor":
     __UpperCamelCase				      =  AutoFeatureExtractor.from_pretrained(args.model       )
    elif args.preprocessor == "processor":
     __UpperCamelCase				      =  AutoProcessor.from_pretrained(args.model       )
    else:
     raise ValueError(f"Unknown preprocessor type '{args.preprocessor}'"       )
  
    # Ensure the requested opset is sufficient
    if args.opset is None:
     __UpperCamelCase				      =  onnx_config.default_onnx_opset
  
    if args.opset < onnx_config.default_onnx_opset:
     raise ValueError(
         f"Opset {args.opset} is not sufficient to export {model_kind}. "
         f"At least  {onnx_config.default_onnx_opset} is required."       )
  
    __UpperCamelCase      ,		__UpperCamelCase				      =  export(
        __A							,__A							,__A							,args.opset							,args.output							,)
  
    if args.atol is None:
     __UpperCamelCase				      =  onnx_config.atol_for_validation
  
    validate_model_outputs(__A							,__A							,__A							,args.output							,__A							,args.atol       )
    logger.info(f"All good, model saved at: {args.output.as_posix()}"       )
    warnings.warn(
        """The export was done by transformers.onnx which is deprecated and will be removed in v5. We recommend"""
        """ using optimum.exporters.onnx in future. You can find more information here:"""
        """ https://huggingface.co/docs/optimum/exporters/onnx/usage_guides/export_a_model."""							,__A							,)
  
  
  
  
  
  
  
  def _lowercase   (  ):
  
  
  
   '''simple docstring'''
  
  
  
   __UpperCamelCase				      =  ArgumentParser("""Hugging Face Transformers ONNX exporter"""       )
   parser.add_argument(
       """-m"""							,"""--model"""							,type=__A							,required=__A							,help="""Model ID on huggingface.co or path on disk to load model from."""       )
   parser.add_argument(
       """--feature"""							,default="""default"""							,help="""The type of features to export the model with."""							,)
   parser.add_argument("""--opset"""							,type=__A							,default=__A							,help="""ONNX opset version to export the model with."""       )
   parser.add_argument(
       """--atol"""							,type=__A							,default=__A							,help="""Absolute difference tolerance when validating the model."""       )
   parser.add_argument(
       """--framework"""							,type=__A							,choices=["""pt""", """tf"""]							,default=__A							,help=(
           """The framework to use for the ONNX export."""
           """ If not provided, will attempt to use the local checkpoint's original framework"""
           """ or what is available in the environment."""
       )							,)
   parser.add_argument("""output"""							,type=__A							,help="""Path indicating where to store generated ONNX model."""       )
   parser.add_argument("""--cache_dir"""							,type=__A							,default=__A							,help="""Path indicating where to store cache."""       )
   parser.add_argument(
       """--preprocessor"""							,type=__A							,choices=["""auto""", """tokenizer""", """feature_extractor""", """image_processor""", """processor"""]							,default="""auto"""							,help="""Which type of preprocessor to use. 'auto' tries to automatically detect it."""							,)
   parser.add_argument(
       """--export_with_transformers"""							,action="""store_true"""							,help=(
           """Whether to use transformers.onnx instead of optimum.exporters.onnx to perform the ONNX export. It can be """
           """useful when exporting a model supported in transformers but not in optimum, otherwise it is not """
           """recommended."""
       )							,)
  
   __UpperCamelCase				      =  parser.parse_args()
   if args.export_with_transformers or not is_optimum_available():
    export_with_transformers(__A       )
   else:
    export_with_optimum(__A       )
  
  
  if __name__ == "__main__":
   a__						:			str										=			logging.get_logger('transformers.onnx')  # pylint: disable=invalid-name
   logger.setLevel(logging.INFO)
   main()
  
  
  
  
  
  
style_context: 
  
  
  
  '''simple docstring'''
  
  
  
  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        UpperCAmelCase__  :
  
  
  
   def __init__(  self		,	lowercase		,	lowercase=1_3		,	lowercase=7		,	lowercase=True		,	lowercase=True		,	lowercase=True		,	lowercase=True		,	lowercase=9_9		,	lowercase=[1, 1, 2]		,	lowercase=1		,	lowercase=3_2		,	lowercase=4		,	lowercase=8		,	lowercase=3_7		,	lowercase="gelu_new"		,	lowercase=0.1		,	lowercase=0.1		,	lowercase=0.0		,	lowercase=5_1_2		,	lowercase=3		,	lowercase=0.02		,	lowercase=3		,	lowercase=4		,	lowercase=None		,	lowercase=False		,	)  ->							Any:
    __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				      =  block_sizes
    __UpperCamelCase				      =  num_decoder_layers
    __UpperCamelCase				      =  d_model
    __UpperCamelCase				      =  n_head
    __UpperCamelCase				      =  d_head
    __UpperCamelCase				      =  d_inner
    __UpperCamelCase				      =  hidden_act
    __UpperCamelCase				      =  hidden_dropout
    __UpperCamelCase				      =  attention_dropout
    __UpperCamelCase				      =  activation_dropout
    __UpperCamelCase				      =  max_position_embeddings
    __UpperCamelCase				      =  type_vocab_size
    __UpperCamelCase				      =  2
    __UpperCamelCase				      =  num_labels
    __UpperCamelCase				      =  num_choices
    __UpperCamelCase				      =  scope
    __UpperCamelCase				      =  initializer_std
  
    # Used in the tests to check the size of the first attention layer
    __UpperCamelCase				      =  n_head
    # Used in the tests to check the size of the first hidden state
    __UpperCamelCase				      =  self.d_model
    # Used in the tests to check the number of output hidden states/attentions
    __UpperCamelCase				      =  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:
     __UpperCamelCase				      =  self.num_hidden_layers + 2
  
  
  
   def    __lowerCamelCase				(  self			)  ->							Tuple:
    __UpperCamelCase				      =  ids_tensor([self.batch_size, self.seq_length]		,	self.vocab_size			)
  
    __UpperCamelCase				      =  None
    if self.use_input_mask:
     __UpperCamelCase				      =  ids_tensor([self.batch_size, self.seq_length]		,	vocab_size=2			)
  
    __UpperCamelCase				      =  None
    if self.use_token_type_ids:
     __UpperCamelCase				      =  ids_tensor([self.batch_size, self.seq_length]		,	self.type_vocab_size			)
  
    __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				      =  ids_tensor([self.batch_size, self.seq_length]		,	1			)
  
    __UpperCamelCase				      =  self.get_config()
  
    return (
        config,
        input_ids,
        token_type_ids,
        input_mask,
        sequence_labels,
        token_labels,
        choice_labels,
        fake_token_labels,
    )
  
  
  
   def    __lowerCamelCase				(  self			)  ->							Any:
    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    __lowerCamelCase				(  self		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	)  ->							Any:
    __UpperCamelCase				      =  FunnelModel(config=lowercase			)
    model.to(lowercase			)
    model.eval()
    __UpperCamelCase				      =  model(lowercase		,	attention_mask=lowercase		,	token_type_ids=lowercase			)
    __UpperCamelCase				      =  model(lowercase		,	token_type_ids=lowercase			)
    __UpperCamelCase				      =  model(lowercase			)
    self.parent.assertEqual(result.last_hidden_state.shape		,	(self.batch_size, self.seq_length, self.d_model)			)
  
    __UpperCamelCase				      =  False
    __UpperCamelCase				      =  model(lowercase			)
    self.parent.assertEqual(result.last_hidden_state.shape		,	(self.batch_size, self.seq_length, self.d_model)			)
  
    __UpperCamelCase				      =  False
    __UpperCamelCase				      =  model(lowercase			)
    self.parent.assertEqual(result.last_hidden_state.shape		,	(self.batch_size, self.seq_length, self.d_model)			)
  
  
  
   def    __lowerCamelCase				(  self		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	)  ->							str:
    __UpperCamelCase				      =  FunnelBaseModel(config=lowercase			)
    model.to(lowercase			)
    model.eval()
    __UpperCamelCase				      =  model(lowercase		,	attention_mask=lowercase		,	token_type_ids=lowercase			)
    __UpperCamelCase				      =  model(lowercase		,	token_type_ids=lowercase			)
    __UpperCamelCase				      =  model(lowercase			)
    self.parent.assertEqual(result.last_hidden_state.shape		,	(self.batch_size, 2, self.d_model)			)
  
    __UpperCamelCase				      =  False
    __UpperCamelCase				      =  model(lowercase			)
    self.parent.assertEqual(result.last_hidden_state.shape		,	(self.batch_size, 3, self.d_model)			)
  
    __UpperCamelCase				      =  False
    __UpperCamelCase				      =  model(lowercase			)
    self.parent.assertEqual(result.last_hidden_state.shape		,	(self.batch_size, 2, self.d_model)			)
  
  
  
   def    __lowerCamelCase				(  self		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	)  ->							Optional[Any]:
    __UpperCamelCase				      =  self.num_labels
    __UpperCamelCase				      =  FunnelForPreTraining(config=lowercase			)
    model.to(lowercase			)
    model.eval()
    __UpperCamelCase				      =  model(lowercase		,	attention_mask=lowercase		,	token_type_ids=lowercase		,	labels=lowercase			)
    self.parent.assertEqual(result.logits.shape		,	(self.batch_size, self.seq_length)			)
  
  
  
   def    __lowerCamelCase				(  self		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	)  ->							Optional[Any]:
    __UpperCamelCase				      =  FunnelForMaskedLM(config=lowercase			)
    model.to(lowercase			)
    model.eval()
    __UpperCamelCase				      =  model(lowercase		,	attention_mask=lowercase		,	token_type_ids=lowercase		,	labels=lowercase			)
    self.parent.assertEqual(result.logits.shape		,	(self.batch_size, self.seq_length, self.vocab_size)			)
  
  
  
   def    __lowerCamelCase				(  self		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	)  ->							Any:
    __UpperCamelCase				      =  self.num_labels
    __UpperCamelCase				      =  FunnelForSequenceClassification(lowercase			)
    model.to(lowercase			)
    model.eval()
    __UpperCamelCase				      =  model(lowercase		,	attention_mask=lowercase		,	token_type_ids=lowercase		,	labels=lowercase			)
    self.parent.assertEqual(result.logits.shape		,	(self.batch_size, self.num_labels)			)
  
  
  
   def    __lowerCamelCase				(  self		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	)  ->							int:
    __UpperCamelCase				      =  self.num_choices
    __UpperCamelCase				      =  FunnelForMultipleChoice(config=lowercase			)
    model.to(lowercase			)
    model.eval()
    __UpperCamelCase				      =  input_ids.unsqueeze(1			).expand(-1		,	self.num_choices		,	-1			).contiguous()
    __UpperCamelCase				      =  token_type_ids.unsqueeze(1			).expand(-1		,	self.num_choices		,	-1			).contiguous()
    __UpperCamelCase				      =  input_mask.unsqueeze(1			).expand(-1		,	self.num_choices		,	-1			).contiguous()
    __UpperCamelCase				      =  model(
        lowercase		,	attention_mask=lowercase		,	token_type_ids=lowercase		,	labels=lowercase		,	)
    self.parent.assertEqual(result.logits.shape		,	(self.batch_size, self.num_choices)			)
  
  
  
   def    __lowerCamelCase				(  self		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	)  ->							Optional[Any]:
    __UpperCamelCase				      =  self.num_labels
    __UpperCamelCase				      =  FunnelForTokenClassification(config=lowercase			)
    model.to(lowercase			)
    model.eval()
    __UpperCamelCase				      =  model(lowercase		,	attention_mask=lowercase		,	token_type_ids=lowercase		,	labels=lowercase			)
    self.parent.assertEqual(result.logits.shape		,	(self.batch_size, self.seq_length, self.num_labels)			)
  
  
  
   def    __lowerCamelCase				(  self		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	lowercase		,	)  ->							Any:
    __UpperCamelCase				      =  FunnelForQuestionAnswering(config=lowercase			)
    model.to(lowercase			)
    model.eval()
    __UpperCamelCase				      =  model(
        lowercase		,	attention_mask=lowercase		,	token_type_ids=lowercase		,	start_positions=lowercase		,	end_positions=lowercase		,	)
    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    __lowerCamelCase				(  self			)  ->							Any:
    __UpperCamelCase				      =  self.prepare_config_and_inputs()
    (
        (
        __UpperCamelCase
    )      ,		(
        __UpperCamelCase
    )      ,		(
        __UpperCamelCase
    )      ,		(
        __UpperCamelCase
    )      ,		(
        __UpperCamelCase
    )      ,		(
        __UpperCamelCase
    )      ,		(
        __UpperCamelCase
    )      ,		(
        __UpperCamelCase
    )      ,		
    )				      =  config_and_inputs
    __UpperCamelCase				      =  {"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
    return config, inputs_dict
  
  
  @require_torch
  class        UpperCAmelCase__  (    UpperCAmelCase_							,			UpperCAmelCase_							,			unittest.TestCase):
   __SCREAMING_SNAKE_CASE					      =				False
   __SCREAMING_SNAKE_CASE					      =				False
   __SCREAMING_SNAKE_CASE					      =				(
       (
           FunnelModel,
           FunnelForMaskedLM,
           FunnelForPreTraining,
           FunnelForQuestionAnswering,
           FunnelForTokenClassification,
       )
       if is_torch_available()
       else ()
   )
   __SCREAMING_SNAKE_CASE					      =				(
       {
           '''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    __lowerCamelCase				(  self		,	lowercase		,	lowercase		,	lowercase=False			)  ->							Tuple:
    __UpperCamelCase				      =  super()._prepare_for_class(lowercase		,	lowercase		,	return_labels=lowercase			)
  
    if return_labels:
     if model_class in get_values(lowercase			):
      __UpperCamelCase				      =  torch.zeros(
          (self.model_tester.batch_size, self.model_tester.seq_length)		,	dtype=torch.long		,	device=lowercase			)
    return inputs_dict
  
  
  
   def    __lowerCamelCase				(  self			)  ->							List[str]:
    __UpperCamelCase				      =  FunnelModelTester(self			)
    __UpperCamelCase				      =  ConfigTester(self		,	config_class=lowercase			)
  
  
  
   def    __lowerCamelCase				(  self			)  ->							Tuple:
    self.config_tester.run_common_tests()
  
  
  
   def    __lowerCamelCase				(  self			)  ->							List[str]:
    __UpperCamelCase				      =  self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model(*lowercase			)
  
  
  
   def    __lowerCamelCase				(  self			)  ->							Optional[int]:
    __UpperCamelCase				      =  self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_pretraining(*lowercase			)
  
  
  
   def    __lowerCamelCase				(  self			)  ->							str:
    __UpperCamelCase				      =  self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_masked_lm(*lowercase			)
  
  
  
   def    __lowerCamelCase				(  self			)  ->							Dict:
    __UpperCamelCase				      =  self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_token_classification(*lowercase			)
  
  
  
   def    __lowerCamelCase				(  self			)  ->							Tuple:
    __UpperCamelCase				      =  self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_question_answering(*lowercase			)
  
  
  
  
   def    __lowerCamelCase				(  self		,	lowercase			)  ->							int:
    if hasattr(lowercase		,	"""weight"""			) and module.weight is not None:
     module.weight.data.fill_(3			)
    if hasattr(lowercase		,	"""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(lowercase		,	lowercase			) and getattr(lowercase		,	lowercase			) is not None:
      __UpperCamelCase				      =  getattr(lowercase		,	lowercase			)
      weight.data.fill_(3			)
  
  
  @require_torch
  class        UpperCAmelCase__  (    UpperCAmelCase_							,			unittest.TestCase):
   __SCREAMING_SNAKE_CASE					      =				False
   __SCREAMING_SNAKE_CASE					      =				False
   __SCREAMING_SNAKE_CASE					      =				(
       (FunnelBaseModel, FunnelForMultipleChoice, FunnelForSequenceClassification) if is_torch_available() else ()
   )
  
  
  
   def    __lowerCamelCase				(  self			)  ->							Optional[int]:
    __UpperCamelCase				      =  FunnelModelTester(self		,	base=lowercase			)
    __UpperCamelCase				      =  ConfigTester(self		,	config_class=lowercase			)
  
  
  
   def    __lowerCamelCase				(  self			)  ->							Any:
    self.config_tester.run_common_tests()
  
  
  
   def    __lowerCamelCase				(  self			)  ->							str:
    __UpperCamelCase				      =  self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_base_model(*lowercase			)
  
  
  
   def    __lowerCamelCase				(  self			)  ->							Any:
    __UpperCamelCase				      =  self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_sequence_classification(*lowercase			)
  
  
  
   def    __lowerCamelCase				(  self			)  ->							Any:
    __UpperCamelCase				      =  self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_multiple_choice(*lowercase			)
  
  
  
   def    __lowerCamelCase				(  self			)  ->							str:
    __UpperCamelCase      ,		__UpperCamelCase				      =  self.model_tester.prepare_config_and_inputs_for_common()
    __UpperCamelCase				      =  True
  
    for model_class in self.all_model_classes:
     if model_class.__name__ == "FunnelBaseModel":
      continue
     __UpperCamelCase				      =  model_class(lowercase			)
     model.to(lowercase			)
     model.train()
     __UpperCamelCase				      =  self._prepare_for_class(lowercase		,	lowercase		,	return_labels=lowercase			)
     __UpperCamelCase				      =  model(**lowercase			).loss
     loss.backward()
  
  
  
  
   def    __lowerCamelCase				(  self		,	lowercase			)  ->							List[Any]:
    if hasattr(lowercase		,	"""weight"""			) and module.weight is not None:
     module.weight.data.fill_(3			)
    if hasattr(lowercase		,	"""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(lowercase		,	lowercase			) and getattr(lowercase		,	lowercase			) is not None:
      __UpperCamelCase				      =  getattr(lowercase		,	lowercase			)
      weight.data.fill_(3			)
  
  
  @require_torch
  @require_sentencepiece
  @require_tokenizers
  class        UpperCAmelCase__  (    unittest.TestCase):
  
  
  
   def    __lowerCamelCase				(  self			)  ->							Tuple:
    __UpperCamelCase				      =  1_3
    __UpperCamelCase				      =  7
    __UpperCamelCase				      =  torch.arange(0		,	batch_size * sequence_length			).long().reshape(lowercase		,	lowercase			)
    __UpperCamelCase				      =  [0, 1, 2, 3, 4, 5, 6, 4, 1, 3, 5, 0, 1]
    __UpperCamelCase				      =  torch.tensor([[2] + [0] * a + [1] * (sequence_length - a - 1) for a in lengths]			)
  
    __UpperCamelCase				      =  FunnelModel.from_pretrained("""sgugger/funnel-random-tiny"""			)
    __UpperCamelCase				      =  model(lowercase		,	token_type_ids=lowercase			)[0].abs()
  
    __UpperCamelCase				      =  torch.tensor(2_344.8_352			)
    __UpperCamelCase				      =  torch.tensor(0.8_052			)
    self.assertTrue(torch.allclose(output.sum()		,	lowercase		,	atol=1E-4			)			)
    self.assertTrue(torch.allclose(output.mean()		,	lowercase		,	atol=1E-4			)			)
  
    __UpperCamelCase				      =  torch.tensor([[1] * 7, [1] * 4 + [0] * 3] * 6 + [[0, 1, 1, 0, 0, 1, 1]]			)
    __UpperCamelCase				      =  model(lowercase		,	attention_mask=lowercase		,	token_type_ids=lowercase			)[0].abs()
  
    __UpperCamelCase				      =  torch.tensor(2_343.8_425			)
    __UpperCamelCase				      =  torch.tensor(0.8_049			)
    self.assertTrue(torch.allclose(output.sum()		,	lowercase		,	atol=1E-4			)			)
    self.assertTrue(torch.allclose(output.mean()		,	lowercase		,	atol=1E-4			)			)
  
  
  
  
   @slow
   def    __lowerCamelCase				(  self			)  ->							Optional[int]:
    __UpperCamelCase				      =  FunnelTokenizer.from_pretrained("""huggingface/funnel-small"""			)
    __UpperCamelCase				      =  FunnelModel.from_pretrained("""huggingface/funnel-small"""			)
    __UpperCamelCase				      =  tokenizer("""Hello! I am the Funnel Transformer model."""		,	return_tensors="""pt"""			)
    __UpperCamelCase				      =  model(**lowercase			)[0]
  
    __UpperCamelCase				      =  torch.tensor(235.7_246			)
    __UpperCamelCase				      =  torch.tensor(0.0_256			)
    self.assertTrue(torch.allclose(output.sum()		,	lowercase		,	atol=1E-4			)			)
    self.assertTrue(torch.allclose(output.mean()		,	lowercase		,	atol=1E-4			)			)
  
  
  
  
  
  