





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

      def __init__(			self   :Any						,							_lowerCamelCase   :str						,							_lowerCamelCase   :str=1_3						,							_lowerCamelCase   :str=7						,							_lowerCamelCase   :Optional[Any]=True						,							_lowerCamelCase   :Dict=True						,							_lowerCamelCase   :Optional[int]=True						,							_lowerCamelCase   :int=True						,							_lowerCamelCase   :List[Any]=9_9						,							_lowerCamelCase   :Any=[1, 1, 2]						,							_lowerCamelCase   :Union[str, Any]=1						,							_lowerCamelCase   :Union[str, Any]=3_2						,							_lowerCamelCase   :Tuple=4						,							_lowerCamelCase   :Optional[int]=8						,							_lowerCamelCase   :str=3_7						,							_lowerCamelCase   :Optional[Any]="gelu_new"						,							_lowerCamelCase   :Any=0.1						,							_lowerCamelCase   :Tuple=0.1						,							_lowerCamelCase   :Any=0.0						,							_lowerCamelCase   :List[str]=5_1_2						,							_lowerCamelCase   :Optional[Any]=3						,							_lowerCamelCase   :Union[str, Any]=0.0_2						,							_lowerCamelCase   :List[Any]=3						,							_lowerCamelCase   :List[str]=4						,							_lowerCamelCase   :Union[str, Any]=None						,							_lowerCamelCase   :Dict=False						,							):
       __SCREAMING_SNAKE_CASE :			Dict												=       parent
       __SCREAMING_SNAKE_CASE :			Dict												=       batch_size
       __SCREAMING_SNAKE_CASE :			Tuple												=       seq_length
       __SCREAMING_SNAKE_CASE :			Optional[int]												=       is_training
       __SCREAMING_SNAKE_CASE :			int												=       use_input_mask
       __SCREAMING_SNAKE_CASE :			Tuple												=       use_token_type_ids
       __SCREAMING_SNAKE_CASE :			Any												=       use_labels
       __SCREAMING_SNAKE_CASE :			str												=       vocab_size
       __SCREAMING_SNAKE_CASE :			Any												=       block_sizes
       __SCREAMING_SNAKE_CASE :			Optional[Any]												=       num_decoder_layers
       __SCREAMING_SNAKE_CASE :			Union[str, Any]												=       d_model
       __SCREAMING_SNAKE_CASE :			Optional[Any]												=       n_head
       __SCREAMING_SNAKE_CASE :			Any												=       d_head
       __SCREAMING_SNAKE_CASE :			Tuple												=       d_inner
       __SCREAMING_SNAKE_CASE :			Tuple												=       hidden_act
       __SCREAMING_SNAKE_CASE :			Dict												=       hidden_dropout
       __SCREAMING_SNAKE_CASE :			List[str]												=       attention_dropout
       __SCREAMING_SNAKE_CASE :			Optional[Any]												=       activation_dropout
       __SCREAMING_SNAKE_CASE :			List[str]												=       max_position_embeddings
       __SCREAMING_SNAKE_CASE :			Dict												=       type_vocab_size
       __SCREAMING_SNAKE_CASE :			Tuple												=       2
       __SCREAMING_SNAKE_CASE :			Any												=       num_labels
       __SCREAMING_SNAKE_CASE :			Optional[Any]												=       num_choices
       __SCREAMING_SNAKE_CASE :			Optional[int]												=       scope
       __SCREAMING_SNAKE_CASE :			List[Any]												=       initializer_std

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

      def 						SCREAMING_SNAKE_CASE_			(			self   :List[Any]						):
       __SCREAMING_SNAKE_CASE :			List[Any]												=       ids_tensor([self.batch_size, self.seq_length]						,							self.vocab_size						)

       __SCREAMING_SNAKE_CASE :			Tuple												=       None
       if self.use_input_mask:
        __SCREAMING_SNAKE_CASE :			Tuple												=       ids_tensor([self.batch_size, self.seq_length]						,							vocab_size=2						)

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

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

       __SCREAMING_SNAKE_CASE :			Any												=       self.get_config()

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

      def 						SCREAMING_SNAKE_CASE_			(			self   :List[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 						SCREAMING_SNAKE_CASE_			(			self   :Any						,							_lowerCamelCase   :Optional[int]						,							_lowerCamelCase   :List[Any]						,							_lowerCamelCase   :Dict						,							_lowerCamelCase   :str						,							_lowerCamelCase   :List[Any]						,							_lowerCamelCase   :Optional[int]						,							_lowerCamelCase   :List[str]						,							_lowerCamelCase   :Union[str, Any]						,							):
       __SCREAMING_SNAKE_CASE :			Union[str, Any]												=       FunnelModel(config=_lowerCamelCase						)
       model.to(_lowerCamelCase						)
       model.eval()
       __SCREAMING_SNAKE_CASE :			Optional[int]												=       model(_lowerCamelCase						,							attention_mask=_lowerCamelCase						,							token_type_ids=_lowerCamelCase						)
       __SCREAMING_SNAKE_CASE :			Tuple												=       model(_lowerCamelCase						,							token_type_ids=_lowerCamelCase						)
       __SCREAMING_SNAKE_CASE :			int												=       model(_lowerCamelCase						)
       self.parent.assertEqual(result.last_hidden_state.shape						,							(self.batch_size, self.seq_length, self.d_model)						)

       __SCREAMING_SNAKE_CASE :			Union[str, Any]												=       False
       __SCREAMING_SNAKE_CASE :			List[str]												=       model(_lowerCamelCase						)
       self.parent.assertEqual(result.last_hidden_state.shape						,							(self.batch_size, self.seq_length, self.d_model)						)

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

      def 						SCREAMING_SNAKE_CASE_			(			self   :Dict						,							_lowerCamelCase   :Union[str, Any]						,							_lowerCamelCase   :int						,							_lowerCamelCase   :int						,							_lowerCamelCase   :Dict						,							_lowerCamelCase   :List[Any]						,							_lowerCamelCase   :Tuple						,							_lowerCamelCase   :Union[str, Any]						,							_lowerCamelCase   :Optional[Any]						,							):
       __SCREAMING_SNAKE_CASE :			Optional[Any]												=       FunnelBaseModel(config=_lowerCamelCase						)
       model.to(_lowerCamelCase						)
       model.eval()
       __SCREAMING_SNAKE_CASE :			Dict												=       model(_lowerCamelCase						,							attention_mask=_lowerCamelCase						,							token_type_ids=_lowerCamelCase						)
       __SCREAMING_SNAKE_CASE :			str												=       model(_lowerCamelCase						,							token_type_ids=_lowerCamelCase						)
       __SCREAMING_SNAKE_CASE :			List[Any]												=       model(_lowerCamelCase						)
       self.parent.assertEqual(result.last_hidden_state.shape						,							(self.batch_size, 2, self.d_model)						)

       __SCREAMING_SNAKE_CASE :			Optional[int]												=       False
       __SCREAMING_SNAKE_CASE :			List[str]												=       model(_lowerCamelCase						)
       self.parent.assertEqual(result.last_hidden_state.shape						,							(self.batch_size, 3, self.d_model)						)

       __SCREAMING_SNAKE_CASE :			List[Any]												=       False
       __SCREAMING_SNAKE_CASE :			Optional[int]												=       model(_lowerCamelCase						)
       self.parent.assertEqual(result.last_hidden_state.shape						,							(self.batch_size, 2, self.d_model)						)

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

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

      def 						SCREAMING_SNAKE_CASE_			(			self   :str						,							_lowerCamelCase   :str						,							_lowerCamelCase   :Optional[int]						,							_lowerCamelCase   :Optional[Any]						,							_lowerCamelCase   :Union[str, Any]						,							_lowerCamelCase   :List[Any]						,							_lowerCamelCase   :str						,							_lowerCamelCase   :List[str]						,							_lowerCamelCase   :Any						,							):
       __SCREAMING_SNAKE_CASE :			List[str]												=       self.num_labels
       __SCREAMING_SNAKE_CASE :			Optional[Any]												=       FunnelForSequenceClassification(_lowerCamelCase						)
       model.to(_lowerCamelCase						)
       model.eval()
       __SCREAMING_SNAKE_CASE :			Optional[int]												=       model(_lowerCamelCase						,							attention_mask=_lowerCamelCase						,							token_type_ids=_lowerCamelCase						,							labels=_lowerCamelCase						)
       self.parent.assertEqual(result.logits.shape						,							(self.batch_size, self.num_labels)						)

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

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

      def 						SCREAMING_SNAKE_CASE_			(			self   :List[Any]						,							_lowerCamelCase   :int						,							_lowerCamelCase   :int						,							_lowerCamelCase   :Union[str, Any]						,							_lowerCamelCase   :Optional[int]						,							_lowerCamelCase   :Any						,							_lowerCamelCase   :Optional[int]						,							_lowerCamelCase   :Any						,							_lowerCamelCase   :Any						,							):
       __SCREAMING_SNAKE_CASE :			Any												=       FunnelForQuestionAnswering(config=_lowerCamelCase						)
       model.to(_lowerCamelCase						)
       model.eval()
       __SCREAMING_SNAKE_CASE :			Optional[Any]												=       model(
           _lowerCamelCase						,							attention_mask=_lowerCamelCase						,							token_type_ids=_lowerCamelCase						,							start_positions=_lowerCamelCase						,							end_positions=_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 						SCREAMING_SNAKE_CASE_			(			self   :List[Any]						):
       __SCREAMING_SNAKE_CASE :			Tuple												=       self.prepare_config_and_inputs()
       (
           (
           __SCREAMING_SNAKE_CASE
       )							,      (
           __SCREAMING_SNAKE_CASE
       )							,      (
           __SCREAMING_SNAKE_CASE
       )							,      (
           __SCREAMING_SNAKE_CASE
       )							,      (
           __SCREAMING_SNAKE_CASE
       )							,      (
           __SCREAMING_SNAKE_CASE
       )							,      (
           __SCREAMING_SNAKE_CASE
       )							,      (
           __SCREAMING_SNAKE_CASE
       )							,      
       ) :			Union[str, Any]												=       config_and_inputs
       __SCREAMING_SNAKE_CASE :			Optional[int]												=       {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
       return config, inputs_dict







@require_torch
class 			snake_case		(   __UpperCAmelCase ,     __UpperCAmelCase ,     unittest.TestCase   ):
      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 						SCREAMING_SNAKE_CASE_			(			self   :Any						,							_lowerCamelCase   :int						,							_lowerCamelCase   :Union[str, Any]						,							_lowerCamelCase   :Tuple=False						):
       __SCREAMING_SNAKE_CASE :			Optional[Any]												=       super()._prepare_for_class(_lowerCamelCase						,							_lowerCamelCase						,							return_labels=_lowerCamelCase						)

       if return_labels:
        if model_class in get_values(_lowerCamelCase						):
         __SCREAMING_SNAKE_CASE :			List[Any]												=       torch.zeros(
             (self.model_tester.batch_size, self.model_tester.seq_length)						,							dtype=torch.long						,							device=_lowerCamelCase						)
       return inputs_dict

      def 						SCREAMING_SNAKE_CASE_			(			self   :Tuple						):
       __SCREAMING_SNAKE_CASE :			Optional[Any]												=       FunnelModelTester(self						)
       __SCREAMING_SNAKE_CASE :			Dict												=       ConfigTester(self						,							config_class=_lowerCamelCase						)

      def 						SCREAMING_SNAKE_CASE_			(			self   :Optional[Any]						):
       self.config_tester.run_common_tests()

      def 						SCREAMING_SNAKE_CASE_			(			self   :Union[str, Any]						):
       __SCREAMING_SNAKE_CASE :			Union[str, Any]												=       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_lowerCamelCase						)

      def 						SCREAMING_SNAKE_CASE_			(			self   :Optional[int]						):
       __SCREAMING_SNAKE_CASE :			Optional[Any]												=       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_pretraining(*_lowerCamelCase						)

      def 						SCREAMING_SNAKE_CASE_			(			self   :int						):
       __SCREAMING_SNAKE_CASE :			Dict												=       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_lm(*_lowerCamelCase						)

      def 						SCREAMING_SNAKE_CASE_			(			self   :List[str]						):
       __SCREAMING_SNAKE_CASE :			Optional[int]												=       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_token_classification(*_lowerCamelCase						)

      def 						SCREAMING_SNAKE_CASE_			(			self   :Any						):
       __SCREAMING_SNAKE_CASE :			Dict												=       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_question_answering(*_lowerCamelCase						)



      def 						SCREAMING_SNAKE_CASE_			(			self   :Optional[Any]						,							_lowerCamelCase   :Dict						):
       if hasattr(_lowerCamelCase						,							'''weight'''						) and module.weight is not None:
        module.weight.data.fill_(3						)
       if hasattr(_lowerCamelCase						,							'''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(_lowerCamelCase						,							_lowerCamelCase						) and getattr(_lowerCamelCase						,							_lowerCamelCase						) is not None:
         __SCREAMING_SNAKE_CASE :			Optional[int]												=       getattr(_lowerCamelCase						,							_lowerCamelCase						)
         weight.data.fill_(3						)







@require_torch
class 			snake_case		(   __UpperCAmelCase ,     unittest.TestCase   ):
      lowerCamelCase__						= False
      lowerCamelCase__						= False
      lowerCamelCase__						= (
          (FunnelBaseModel, FunnelForMultipleChoice, FunnelForSequenceClassification) if is_torch_available() else ()
      )

      def 						SCREAMING_SNAKE_CASE_			(			self   :Optional[Any]						):
       __SCREAMING_SNAKE_CASE :			Dict												=       FunnelModelTester(self						,							base=_lowerCamelCase						)
       __SCREAMING_SNAKE_CASE :			Union[str, Any]												=       ConfigTester(self						,							config_class=_lowerCamelCase						)

      def 						SCREAMING_SNAKE_CASE_			(			self   :Optional[int]						):
       self.config_tester.run_common_tests()

      def 						SCREAMING_SNAKE_CASE_			(			self   :Optional[int]						):
       __SCREAMING_SNAKE_CASE :			int												=       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_base_model(*_lowerCamelCase						)

      def 						SCREAMING_SNAKE_CASE_			(			self   :Dict						):
       __SCREAMING_SNAKE_CASE :			List[str]												=       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_sequence_classification(*_lowerCamelCase						)

      def 						SCREAMING_SNAKE_CASE_			(			self   :Dict						):
       __SCREAMING_SNAKE_CASE :			List[str]												=       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_multiple_choice(*_lowerCamelCase						)

      def 						SCREAMING_SNAKE_CASE_			(			self   :Optional[int]						):
       __SCREAMING_SNAKE_CASE							,      __SCREAMING_SNAKE_CASE :			Optional[int]												=       self.model_tester.prepare_config_and_inputs_for_common()
       __SCREAMING_SNAKE_CASE :			int												=       True

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



      def 						SCREAMING_SNAKE_CASE_			(			self   :Any						,							_lowerCamelCase   :int						):
       if hasattr(_lowerCamelCase						,							'''weight'''						) and module.weight is not None:
        module.weight.data.fill_(3						)
       if hasattr(_lowerCamelCase						,							'''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(_lowerCamelCase						,							_lowerCamelCase						) and getattr(_lowerCamelCase						,							_lowerCamelCase						) is not None:
         __SCREAMING_SNAKE_CASE :			int												=       getattr(_lowerCamelCase						,							_lowerCamelCase						)
         weight.data.fill_(3						)







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

      def 						SCREAMING_SNAKE_CASE_			(			self   :int						):
       __SCREAMING_SNAKE_CASE :			str												=       1_3
       __SCREAMING_SNAKE_CASE :			List[Any]												=       7
       __SCREAMING_SNAKE_CASE :			List[str]												=       torch.arange(0						,							batch_size * sequence_length						).long().reshape(_lowerCamelCase						,							_lowerCamelCase						)
       __SCREAMING_SNAKE_CASE :			List[str]												=       [0, 1, 2, 3, 4, 5, 6, 4, 1, 3, 5, 0, 1]
       __SCREAMING_SNAKE_CASE :			Optional[Any]												=       torch.tensor([[2] + [0] * a + [1] * (sequence_length - a - 1) for a in lengths]						)

       __SCREAMING_SNAKE_CASE :			List[str]												=       FunnelModel.from_pretrained('''sgugger/funnel-random-tiny'''						)
       __SCREAMING_SNAKE_CASE :			List[Any]												=       model(_lowerCamelCase						,							token_type_ids=_lowerCamelCase						)[0].abs()

       __SCREAMING_SNAKE_CASE :			Any												=       torch.tensor(2_3_4_4.8_3_5_2						)
       __SCREAMING_SNAKE_CASE :			int												=       torch.tensor(0.8_0_5_2						)
       self.assertTrue(torch.allclose(output.sum()						,							_lowerCamelCase						,							atol=1e-4						)						)
       self.assertTrue(torch.allclose(output.mean()						,							_lowerCamelCase						,							atol=1e-4						)						)

       __SCREAMING_SNAKE_CASE :			str												=       torch.tensor([[1] * 7, [1] * 4 + [0] * 3] * 6 + [[0, 1, 1, 0, 0, 1, 1]]						)
       __SCREAMING_SNAKE_CASE :			Optional[Any]												=       model(_lowerCamelCase						,							attention_mask=_lowerCamelCase						,							token_type_ids=_lowerCamelCase						)[0].abs()

       __SCREAMING_SNAKE_CASE :			Dict												=       torch.tensor(2_3_4_3.8_4_2_5						)
       __SCREAMING_SNAKE_CASE :			Any												=       torch.tensor(0.8_0_4_9						)
       self.assertTrue(torch.allclose(output.sum()						,							_lowerCamelCase						,							atol=1e-4						)						)
       self.assertTrue(torch.allclose(output.mean()						,							_lowerCamelCase						,							atol=1e-4						)						)



      @slow
      def 						SCREAMING_SNAKE_CASE_			(			self   :Union[str, Any]						):
       __SCREAMING_SNAKE_CASE :			List[Any]												=       FunnelTokenizer.from_pretrained('''huggingface/funnel-small'''						)
       __SCREAMING_SNAKE_CASE :			Optional[int]												=       FunnelModel.from_pretrained('''huggingface/funnel-small'''						)
       __SCREAMING_SNAKE_CASE :			Dict												=       tokenizer('''Hello! I am the Funnel Transformer model.'''						,							return_tensors='''pt'''						)
       __SCREAMING_SNAKE_CASE :			Optional[int]												=       model(**_lowerCamelCase						)[0]

       __SCREAMING_SNAKE_CASE :			List[Any]												=       torch.tensor(2_3_5.7_2_4_6						)
       __SCREAMING_SNAKE_CASE :			int												=       torch.tensor(0.0_2_5_6						)
       self.assertTrue(torch.allclose(output.sum()						,							_lowerCamelCase						,							atol=1e-4						)						)
       self.assertTrue(torch.allclose(output.mean()						,							_lowerCamelCase						,							atol=1e-4						)						)








"""simple docstring"""





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


_lowerCamelCase       =	{
    '''configuration_mobilenet_v1''': [
        '''MOBILENET_V1_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''MobileNetV1Config''',
        '''MobileNetV1OnnxConfig''',
    ],
}

try:
    if not is_vision_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    _lowerCamelCase       =	['''MobileNetV1FeatureExtractor''']
    _lowerCamelCase       =	['''MobileNetV1ImageProcessor''']

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    _lowerCamelCase       =	[
        '''MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST''',
        '''MobileNetV1ForImageClassification''',
        '''MobileNetV1Model''',
        '''MobileNetV1PreTrainedModel''',
        '''load_tf_weights_in_mobilenet_v1''',
    ]


if TYPE_CHECKING:
    from .configuration_mobilenet_va import (
        MOBILENET_V1_PRETRAINED_CONFIG_ARCHIVE_MAP,
        MobileNetVaConfig,
        MobileNetVaOnnxConfig,
    )

    try:
        if not is_vision_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .feature_extraction_mobilenet_va import MobileNetVaFeatureExtractor
        from .image_processing_mobilenet_va import MobileNetVaImageProcessor

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_mobilenet_va import (
            MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST,
            MobileNetVaForImageClassification,
            MobileNetVaModel,
            MobileNetVaPreTrainedModel,
            load_tf_weights_in_mobilenet_va,
        )


else:
    import sys

    _lowerCamelCase       =	_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

