



from typing import Any, Dict, List, Optional, Tuple, Union

import torch
from torch import nn
from torch.utils.data import DistributedSampler, RandomSampler

from transformers import PreTrainedModel, Trainer, logging
from transformers.integrations import is_fairscale_available
from transformers.models.fsmt.configuration_fsmt import FSMTConfig
from transformers.optimization import (
    Adafactor,
    AdamW,
    get_constant_schedule,
    get_constant_schedule_with_warmup,
    get_cosine_schedule_with_warmup,
    get_cosine_with_hard_restarts_schedule_with_warmup,
    get_linear_schedule_with_warmup,
    get_polynomial_decay_schedule_with_warmup,
)
from transformers.trainer_pt_utils import get_tpu_sampler
from transformers.training_args import ParallelMode
from transformers.utils import is_torch_tpu_available


if is_fairscale_available():
       from fairscale.optim import OSS


a__      :				Optional[int]   	=			logging.get_logger(__name__)

a__      :				Any   	=			{
    "linear": get_linear_schedule_with_warmup,
    "cosine": get_cosine_schedule_with_warmup,
    "cosine_w_restarts": get_cosine_with_hard_restarts_schedule_with_warmup,
    "polynomial": get_polynomial_decay_schedule_with_warmup,
    "constant": get_constant_schedule,
    "constant_w_warmup": get_constant_schedule_with_warmup,
}



class       UpperCAmelCase__(							lowerCamelCase	):

   '''simple docstring'''




   def __init__(						self  :			Tuple			,				lowerCAmelCase  :			Dict=None			,				lowerCAmelCase  :			List[str]=None			,				*lowerCAmelCase  :			Tuple			,				**lowerCAmelCase  :			Optional[Any])	->				str:




         """simple docstring"""

         super().__init__(*lowerCAmelCase			,				**lowerCAmelCase)

         if config is None:
               assert isinstance(self.model			,				lowerCAmelCase), (
                   "If no `config` is passed the model to be trained has to be of type `PreTrainedModel`, but is"
                   f''' {self.model.__class__}'''
               )
               lowercase__     =  self.model.config
         else:
               lowercase__     =  config

         lowercase__     =  data_args
         lowercase__     =  self.config.tgt_vocab_size if isinstance(self.config			,				lowerCAmelCase) else self.config.vocab_size

         if self.args.label_smoothing != 0 or (self.data_args is not None and self.data_args.ignore_pad_token_for_loss):
               assert self.config.pad_token_id is not None, (
                   "Make sure that `config.pad_token_id` is correcly defined when ignoring `pad_token` for loss"
                   " calculation or doing label smoothing."
               )

         if self.config.pad_token_id is None and self.config.eos_token_id is not None:
               logger.warning(
                   f'''The `config.pad_token_id` is `None`. Using `config.eos_token_id` = {self.config.eos_token_id} for'''
                   ' padding..')

         if self.args.label_smoothing == 0:
               lowercase__     =  torch.nn.CrossEntropyLoss(ignore_index=self.config.pad_token_id)
         else:
               # dynamically import label_smoothed_nll_loss
               from utils import label_smoothed_nll_loss

               lowercase__     =  label_smoothed_nll_loss


   def 			UpperCAmelCase		(						self  :			Any			,				lowerCAmelCase  :			int)	->				Any:




         """simple docstring"""

         if self.optimizer is None:
               lowercase__     =  ['bias', 'LayerNorm.weight']
               lowercase__     =  [
                   {
                       'params': [p for n, p in self.model.named_parameters() if not any(nd in n for nd in no_decay)],
                       'weight_decay': self.args.weight_decay,
                   },
                   {
                       'params': [p for n, p in self.model.named_parameters() if any(nd in n for nd in no_decay)],
                       'weight_decay': 0.0,
                   },
               ]
               lowercase__     =  Adafactor if self.args.adafactor else AdamW
               if self.args.adafactor:
                     lowercase__     =  Adafactor
                     lowercase__     =  {'scale_parameter': False, 'relative_step': False}
               else:
                     lowercase__     =  AdamW
                     lowercase__     =  {
                         'betas': (self.args.adam_betaa, self.args.adam_betaa),
                         'eps': self.args.adam_epsilon,
                     }
               lowercase__     =  self.args.learning_rate
               if self.sharded_ddp:
                     lowercase__     =  OSS(
                         params=lowerCAmelCase			,				optim=lowerCAmelCase			,				**lowerCAmelCase			,				)
               else:
                     lowercase__     =  optimizer_cls(lowerCAmelCase			,				**lowerCAmelCase)

         if self.lr_scheduler is None:
               lowercase__     =  self._get_lr_scheduler(lowerCAmelCase)
         else:  # ignoring --lr_scheduler
               logger.warning('scheduler is passed to `Seq2SeqTrainer`, `--lr_scheduler` arg is ignored.')


   def 			UpperCAmelCase		(						self  :			Dict			,				lowerCAmelCase  :			List[Any])	->				Dict:




         """simple docstring"""

         lowercase__     =  arg_to_scheduler[self.args.lr_scheduler]
         if self.args.lr_scheduler == "constant":
               lowercase__     =  schedule_func(self.optimizer)
         elif self.args.lr_scheduler == "constant_w_warmup":
               lowercase__     =  schedule_func(self.optimizer			,				num_warmup_steps=self.args.warmup_steps)
         else:
               lowercase__     =  schedule_func(
                   self.optimizer			,				num_warmup_steps=self.args.warmup_steps			,				num_training_steps=lowerCAmelCase)
         return scheduler


   def 			UpperCAmelCase		(						self  :			List[Any])	->				Optional[torch.utils.data.Sampler]:




         """simple docstring"""

         if isinstance(self.train_dataset			,				torch.utils.data.IterableDataset):
               return None
         elif is_torch_tpu_available():
               return get_tpu_sampler(self.train_dataset)
         else:
               if self.args.sortish_sampler:
                     self.train_dataset.make_sortish_sampler(
                         self.args.per_device_train_batch_size			,				distributed=(self.args.parallel_mode == ParallelMode.DISTRIBUTED)			,				)

               return (
                   RandomSampler(self.train_dataset)
                   if self.args.local_rank == -1
                   else DistributedSampler(self.train_dataset)
               )


   def 			UpperCAmelCase		(						self  :			Optional[int]			,				lowerCAmelCase  :			Optional[Any]			,				lowerCAmelCase  :			Any			,				lowerCAmelCase  :			Optional[int])	->				Tuple:




         """simple docstring"""

         if self.args.label_smoothing == 0:
               if self.data_args is not None and self.data_args.ignore_pad_token_for_loss:
                     # force training to ignore pad token
                     lowercase__     =  model(**lowerCAmelCase			,				use_cache=lowerCAmelCase)[0]
                     lowercase__     =  self.loss_fn(logits.view(-1			,				logits.shape[-1])			,				labels.view(-1))
               else:
                     # compute usual loss via models
                     lowercase__,	lowercase__     =  model(**lowerCAmelCase			,				labels=lowerCAmelCase			,				use_cache=lowerCAmelCase)[:2]
         else:
               # compute label smoothed loss
               lowercase__     =  model(**lowerCAmelCase			,				use_cache=lowerCAmelCase)[0]
               lowercase__     =  torch.nn.functional.log_softmax(lowerCAmelCase			,				dim=-1)
               lowercase__,	lowercase__     =  self.loss_fn(lowerCAmelCase			,				lowerCAmelCase			,				self.args.label_smoothing			,				ignore_index=self.config.pad_token_id)
         return loss, logits


   def 			UpperCAmelCase		(						self  :			Optional[int]			,				lowerCAmelCase  :			List[str]			,				lowerCAmelCase  :			Dict)	->				Optional[int]:




         """simple docstring"""

         lowercase__     =  inputs.pop('labels')
         lowercase__,	lowercase__     =  self._compute_loss(lowerCAmelCase			,				lowerCAmelCase			,				lowerCAmelCase)
         return loss


   def 			UpperCAmelCase		(						self  :			Optional[Any]			,				lowerCAmelCase  :			nn.Module			,				lowerCAmelCase  :			Dict[str, Union[torch.Tensor, Any]]			,				lowerCAmelCase  :			bool			,				lowerCAmelCase  :			Optional[List[str]] = None			,				)	->				Tuple[Optional[float], Optional[torch.Tensor], Optional[torch.Tensor]]:




         """simple docstring"""

         lowercase__     =  self._prepare_inputs(lowerCAmelCase)

         lowercase__     =  {
             'max_length': self.data_args.val_max_target_length
             if self.data_args is not None
             else self.config.max_length,
             'num_beams': self.data_args.eval_beams if self.data_args is not None else self.config.num_beams,
         }

         if self.args.predict_with_generate and not self.args.prediction_loss_only:
               lowercase__     =  self.model.generate(
                   inputs['input_ids']			,				attention_mask=inputs['attention_mask']			,				**lowerCAmelCase			,				)
               # in case the batch is shorter than max length, the output should be padded
               if generated_tokens.shape[-1] < gen_kwargs["max_length"]:
                     lowercase__     =  self._pad_tensors_to_max_len(lowerCAmelCase			,				gen_kwargs['max_length'])

         lowercase__     =  inputs.pop('labels')
         with torch.no_grad():
               # compute loss on predict data
               lowercase__,	lowercase__     =  self._compute_loss(lowerCAmelCase			,				lowerCAmelCase			,				lowerCAmelCase)

         lowercase__     =  loss.mean().detach()
         if self.args.prediction_loss_only:
               return (loss, None, None)

         lowercase__     =  generated_tokens if self.args.predict_with_generate else logits

         if labels.shape[-1] < gen_kwargs["max_length"]:
               lowercase__     =  self._pad_tensors_to_max_len(lowerCAmelCase			,				gen_kwargs['max_length'])

         return (loss, logits, labels)



   def 			UpperCAmelCase		(						self  :			Dict			,				lowerCAmelCase  :			Dict			,				lowerCAmelCase  :			Tuple)	->				Tuple:




         """simple docstring"""

         lowercase__     =  self.config.pad_token_id if self.config.pad_token_id is not None else self.config.eos_token_id

         if pad_token_id is None:
               raise ValueError(
                   'Make sure that either `config.pad_token_id` or `config.eos_token_id` is defined if tensor has to be'
                   f''' padded to `max_length`={max_length}''')

         lowercase__     =  pad_token_id * torch.ones(
             (tensor.shape[0], max_length)			,				dtype=tensor.dtype			,				device=tensor.device)
         lowercase__     =  tensor
         return padded_tensor





from __future__ import annotations

import unittest

from transformers import FunnelConfig, is_tf_available
from transformers.testing_utils import require_tf

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
       import tensorflow as tf

       from transformers import (
           TFFunnelBaseModel,
           TFFunnelForMaskedLM,
           TFFunnelForMultipleChoice,
           TFFunnelForPreTraining,
           TFFunnelForQuestionAnswering,
           TFFunnelForSequenceClassification,
           TFFunnelForTokenClassification,
           TFFunnelModel,
       )



class       UpperCAmelCase__:

   '''simple docstring'''




   def __init__(						self  :			Tuple			,				lowerCAmelCase  :			str			,				lowerCAmelCase  :			Dict=13			,				lowerCAmelCase  :			Dict=7			,				lowerCAmelCase  :			int=True			,				lowerCAmelCase  :			Optional[Any]=True			,				lowerCAmelCase  :			str=True			,				lowerCAmelCase  :			int=True			,				lowerCAmelCase  :			List[Any]=99			,				lowerCAmelCase  :			List[Any]=[1, 1, 2]			,				lowerCAmelCase  :			Optional[Any]=1			,				lowerCAmelCase  :			int=32			,				lowerCAmelCase  :			Union[str, Any]=4			,				lowerCAmelCase  :			Tuple=8			,				lowerCAmelCase  :			int=37			,				lowerCAmelCase  :			Any="gelu_new"			,				lowerCAmelCase  :			str=0.1			,				lowerCAmelCase  :			List[str]=0.1			,				lowerCAmelCase  :			Dict=0.0			,				lowerCAmelCase  :			str=5_12			,				lowerCAmelCase  :			str=3			,				lowerCAmelCase  :			List[Any]=0.02			,				lowerCAmelCase  :			Union[str, Any]=3			,				lowerCAmelCase  :			Any=4			,				lowerCAmelCase  :			List[Any]=None			,				lowerCAmelCase  :			Optional[int]=False			,				)	->				List[Any]:




         """simple docstring"""

         lowercase__     =  parent
         lowercase__     =  batch_size
         lowercase__     =  seq_length
         lowercase__     =  is_training
         lowercase__     =  use_input_mask
         lowercase__     =  use_token_type_ids
         lowercase__     =  use_labels
         lowercase__     =  vocab_size
         lowercase__     =  block_sizes
         lowercase__     =  num_decoder_layers
         lowercase__     =  d_model
         lowercase__     =  n_head
         lowercase__     =  d_head
         lowercase__     =  d_inner
         lowercase__     =  hidden_act
         lowercase__     =  hidden_dropout
         lowercase__     =  attention_dropout
         lowercase__     =  activation_dropout
         lowercase__     =  max_position_embeddings
         lowercase__     =  type_vocab_size
         lowercase__     =  2
         lowercase__     =  num_labels
         lowercase__     =  num_choices
         lowercase__     =  scope
         lowercase__     =  initializer_std

         # Used in the tests to check the size of the first attention layer
         lowercase__     =  n_head
         # Used in the tests to check the size of the first hidden state
         lowercase__     =  self.d_model
         # Used in the tests to check the number of output hidden states/attentions
         lowercase__     =  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:
               lowercase__     =  self.num_hidden_layers + 2


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




         """simple docstring"""

         lowercase__     =  ids_tensor([self.batch_size, self.seq_length]			,				self.vocab_size)

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

         lowercase__     =  None
         if self.use_token_type_ids:
               lowercase__     =  ids_tensor([self.batch_size, self.seq_length]			,				self.type_vocab_size)

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

         lowercase__     =  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			,				)

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


   def 			UpperCAmelCase		(						self  :			Dict			,				lowerCAmelCase  :			List[Any]			,				lowerCAmelCase  :			Dict			,				lowerCAmelCase  :			Tuple			,				lowerCAmelCase  :			Union[str, Any]			,				lowerCAmelCase  :			Any			,				lowerCAmelCase  :			Optional[Any]			,				lowerCAmelCase  :			Union[str, Any]			,				)	->				int:




         """simple docstring"""

         lowercase__     =  TFFunnelModel(config=lowerCAmelCase)
         lowercase__     =  {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
         lowercase__     =  model(lowerCAmelCase)

         lowercase__     =  [input_ids, input_mask]
         lowercase__     =  model(lowerCAmelCase)

         lowercase__     =  model(lowerCAmelCase)
         self.parent.assertEqual(result.last_hidden_state.shape			,				(self.batch_size, self.seq_length, self.d_model))

         lowercase__     =  False
         lowercase__     =  TFFunnelModel(config=lowerCAmelCase)
         lowercase__     =  model(lowerCAmelCase)
         self.parent.assertEqual(result.last_hidden_state.shape			,				(self.batch_size, self.seq_length, self.d_model))

         lowercase__     =  False
         lowercase__     =  TFFunnelModel(config=lowerCAmelCase)
         lowercase__     =  model(lowerCAmelCase)
         self.parent.assertEqual(result.last_hidden_state.shape			,				(self.batch_size, self.seq_length, self.d_model))


   def 			UpperCAmelCase		(						self  :			List[str]			,				lowerCAmelCase  :			List[Any]			,				lowerCAmelCase  :			Tuple			,				lowerCAmelCase  :			Optional[int]			,				lowerCAmelCase  :			Any			,				lowerCAmelCase  :			List[str]			,				lowerCAmelCase  :			int			,				lowerCAmelCase  :			Optional[Any]			,				)	->				Optional[Any]:




         """simple docstring"""

         lowercase__     =  TFFunnelBaseModel(config=lowerCAmelCase)
         lowercase__     =  {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
         lowercase__     =  model(lowerCAmelCase)

         lowercase__     =  [input_ids, input_mask]
         lowercase__     =  model(lowerCAmelCase)

         lowercase__     =  model(lowerCAmelCase)
         self.parent.assertEqual(result.last_hidden_state.shape			,				(self.batch_size, 2, self.d_model))

         lowercase__     =  False
         lowercase__     =  TFFunnelBaseModel(config=lowerCAmelCase)
         lowercase__     =  model(lowerCAmelCase)
         self.parent.assertEqual(result.last_hidden_state.shape			,				(self.batch_size, 3, self.d_model))

         lowercase__     =  False
         lowercase__     =  TFFunnelBaseModel(config=lowerCAmelCase)
         lowercase__     =  model(lowerCAmelCase)
         self.parent.assertEqual(result.last_hidden_state.shape			,				(self.batch_size, 2, self.d_model))


   def 			UpperCAmelCase		(						self  :			Tuple			,				lowerCAmelCase  :			Optional[int]			,				lowerCAmelCase  :			Optional[Any]			,				lowerCAmelCase  :			Dict			,				lowerCAmelCase  :			List[str]			,				lowerCAmelCase  :			List[str]			,				lowerCAmelCase  :			str			,				lowerCAmelCase  :			Tuple			,				)	->				str:




         """simple docstring"""

         lowercase__     =  TFFunnelForPreTraining(config=lowerCAmelCase)
         lowercase__     =  {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
         lowercase__     =  model(lowerCAmelCase)
         self.parent.assertEqual(result.logits.shape			,				(self.batch_size, self.seq_length))


   def 			UpperCAmelCase		(						self  :			List[Any]			,				lowerCAmelCase  :			Any			,				lowerCAmelCase  :			str			,				lowerCAmelCase  :			Union[str, Any]			,				lowerCAmelCase  :			List[str]			,				lowerCAmelCase  :			Optional[Any]			,				lowerCAmelCase  :			Tuple			,				lowerCAmelCase  :			Tuple			,				)	->				Optional[int]:




         """simple docstring"""

         lowercase__     =  TFFunnelForMaskedLM(config=lowerCAmelCase)
         lowercase__     =  {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
         lowercase__     =  model(lowerCAmelCase)
         self.parent.assertEqual(result.logits.shape			,				(self.batch_size, self.seq_length, self.vocab_size))


   def 			UpperCAmelCase		(						self  :			Union[str, Any]			,				lowerCAmelCase  :			int			,				lowerCAmelCase  :			Tuple			,				lowerCAmelCase  :			Union[str, Any]			,				lowerCAmelCase  :			Optional[int]			,				lowerCAmelCase  :			Dict			,				lowerCAmelCase  :			Optional[int]			,				lowerCAmelCase  :			List[Any]			,				)	->				Optional[int]:




         """simple docstring"""

         lowercase__     =  self.num_labels
         lowercase__     =  TFFunnelForSequenceClassification(config=lowerCAmelCase)
         lowercase__     =  {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
         lowercase__     =  model(lowerCAmelCase)
         self.parent.assertEqual(result.logits.shape			,				(self.batch_size, self.num_labels))


   def 			UpperCAmelCase		(						self  :			List[Any]			,				lowerCAmelCase  :			str			,				lowerCAmelCase  :			Optional[int]			,				lowerCAmelCase  :			int			,				lowerCAmelCase  :			Optional[int]			,				lowerCAmelCase  :			List[str]			,				lowerCAmelCase  :			Union[str, Any]			,				lowerCAmelCase  :			List[Any]			,				)	->				Optional[Any]:




         """simple docstring"""

         lowercase__     =  self.num_choices
         lowercase__     =  TFFunnelForMultipleChoice(config=lowerCAmelCase)
         lowercase__     =  tf.tile(tf.expand_dims(lowerCAmelCase			,				1)			,				(1, self.num_choices, 1))
         lowercase__     =  tf.tile(tf.expand_dims(lowerCAmelCase			,				1)			,				(1, self.num_choices, 1))
         lowercase__     =  tf.tile(tf.expand_dims(lowerCAmelCase			,				1)			,				(1, self.num_choices, 1))
         lowercase__     =  {
             'input_ids': multiple_choice_inputs_ids,
             'attention_mask': multiple_choice_input_mask,
             'token_type_ids': multiple_choice_token_type_ids,
         }
         lowercase__     =  model(lowerCAmelCase)
         self.parent.assertEqual(result.logits.shape			,				(self.batch_size, self.num_choices))


   def 			UpperCAmelCase		(						self  :			List[str]			,				lowerCAmelCase  :			str			,				lowerCAmelCase  :			List[Any]			,				lowerCAmelCase  :			Tuple			,				lowerCAmelCase  :			Union[str, Any]			,				lowerCAmelCase  :			int			,				lowerCAmelCase  :			Optional[int]			,				lowerCAmelCase  :			Any			,				)	->				Union[str, Any]:




         """simple docstring"""

         lowercase__     =  self.num_labels
         lowercase__     =  TFFunnelForTokenClassification(config=lowerCAmelCase)
         lowercase__     =  {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
         lowercase__     =  model(lowerCAmelCase)
         self.parent.assertEqual(result.logits.shape			,				(self.batch_size, self.seq_length, self.num_labels))


   def 			UpperCAmelCase		(						self  :			int			,				lowerCAmelCase  :			List[str]			,				lowerCAmelCase  :			int			,				lowerCAmelCase  :			Optional[int]			,				lowerCAmelCase  :			List[str]			,				lowerCAmelCase  :			str			,				lowerCAmelCase  :			Tuple			,				lowerCAmelCase  :			Tuple			,				)	->				Optional[int]:




         """simple docstring"""

         lowercase__     =  TFFunnelForQuestionAnswering(config=lowerCAmelCase)
         lowercase__     =  {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
         lowercase__     =  model(lowerCAmelCase)
         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  :			Union[str, Any])	->				str:




         """simple docstring"""

         lowercase__     =  self.prepare_config_and_inputs()
         (
             (
             lowercase__
         ),	(
             lowercase__
         ),	(
             lowercase__
         ),	(
             lowercase__
         ),	(
             lowercase__
         ),	(
             lowercase__
         ),	(
             lowercase__
         ),	
         )     =  config_and_inputs
         lowercase__     =  {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
         return config, inputs_dict



@require_tf
class       UpperCAmelCase__(							lowerCamelCase     ,							lowerCamelCase     ,							unittest.TestCase	):

   '''simple docstring'''




   A    :  int       				=    (
       (
           TFFunnelModel,
           TFFunnelForMaskedLM,
           TFFunnelForPreTraining,
           TFFunnelForQuestionAnswering,
           TFFunnelForTokenClassification,
       )
       if is_tf_available()
       else ()
   )
   A    :  Dict       				=    (
       {
           "feature-extraction": (TFFunnelBaseModel, TFFunnelModel),
           "fill-mask": TFFunnelForMaskedLM,
           "question-answering": TFFunnelForQuestionAnswering,
           "text-classification": TFFunnelForSequenceClassification,
           "token-classification": TFFunnelForTokenClassification,
           "zero-shot": TFFunnelForSequenceClassification,
       }
       if is_tf_available()
       else {}
   )
   A    :  Optional[int]       				=    False
   A    :  Optional[int]       				=    False


   def 			UpperCAmelCase		(						self  :			Tuple)	->				str:




         """simple docstring"""

         lowercase__     =  TFFunnelModelTester(self)
         lowercase__     =  ConfigTester(self			,				config_class=lowerCAmelCase)


   def 			UpperCAmelCase		(						self  :			int)	->				Optional[int]:




         """simple docstring"""

         self.config_tester.run_common_tests()


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




         """simple docstring"""

         lowercase__     =  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*lowerCAmelCase)


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




         """simple docstring"""

         lowercase__     =  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_pretraining(*lowerCAmelCase)


   def 			UpperCAmelCase		(						self  :			int)	->				Union[str, Any]:




         """simple docstring"""

         lowercase__     =  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_lm(*lowerCAmelCase)


   def 			UpperCAmelCase		(						self  :			List[str])	->				Union[str, Any]:




         """simple docstring"""

         lowercase__     =  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(*lowerCAmelCase)



   def 			UpperCAmelCase		(						self  :			Dict)	->				Dict:




         """simple docstring"""

         lowercase__     =  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_question_answering(*lowerCAmelCase)



@require_tf
class       UpperCAmelCase__(							lowerCamelCase     ,							unittest.TestCase	):

   '''simple docstring'''




   A    :  Tuple       				=    (
       (TFFunnelBaseModel, TFFunnelForMultipleChoice, TFFunnelForSequenceClassification) if is_tf_available() else ()
   )
   A    :  List[str]       				=    False
   A    :  int       				=    False


   def 			UpperCAmelCase		(						self  :			Any)	->				List[Any]:




         """simple docstring"""

         lowercase__     =  TFFunnelModelTester(self			,				base=lowerCAmelCase)
         lowercase__     =  ConfigTester(self			,				config_class=lowerCAmelCase)


   def 			UpperCAmelCase		(						self  :			Union[str, Any])	->				Optional[int]:




         """simple docstring"""

         self.config_tester.run_common_tests()


   def 			UpperCAmelCase		(						self  :			Tuple)	->				int:




         """simple docstring"""

         lowercase__     =  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_base_model(*lowerCAmelCase)


   def 			UpperCAmelCase		(						self  :			int)	->				str:




         """simple docstring"""

         lowercase__     =  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_sequence_classification(*lowerCAmelCase)



   def 			UpperCAmelCase		(						self  :			List[str])	->				Optional[Any]:




         """simple docstring"""

         lowercase__     =  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_multiple_choice(*lowerCAmelCase)
