



# Imports
import numpy as np



class       UpperCAmelCase__:

   '''simple docstring'''




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




         """simple docstring"""

         self.set_matricies(red=lowerCAmelCase			,				green=lowerCAmelCase			,				blue=lowerCAmelCase			,				red_edge=lowerCAmelCase			,				nir=lowerCAmelCase)


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




         """simple docstring"""

         if red is not None:
               lowercase__     =  red
         if green is not None:
               lowercase__     =  green
         if blue is not None:
               lowercase__     =  blue
         if red_edge is not None:
               lowercase__     =  red_edge
         if nir is not None:
               lowercase__     =  nir
         return True


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




         """simple docstring"""

         self.set_matricies(red=lowerCAmelCase			,				green=lowerCAmelCase			,				blue=lowerCAmelCase			,				red_edge=lowerCAmelCase			,				nir=lowerCAmelCase)
         lowercase__     =  {
             'ARVI2': self.arvaa,
             'CCCI': self.ccci,
             'CVI': self.cvi,
             'GLI': self.gli,
             'NDVI': self.ndvi,
             'BNDVI': self.bndvi,
             'redEdgeNDVI': self.red_edge_ndvi,
             'GNDVI': self.gndvi,
             'GBNDVI': self.gbndvi,
             'GRNDVI': self.grndvi,
             'RBNDVI': self.rbndvi,
             'PNDVI': self.pndvi,
             'ATSAVI': self.atsavi,
             'BWDRVI': self.bwdrvi,
             'CIgreen': self.ci_green,
             'CIrededge': self.ci_rededge,
             'CI': self.ci,
             'CTVI': self.ctvi,
             'GDVI': self.gdvi,
             'EVI': self.evi,
             'GEMI': self.gemi,
             'GOSAVI': self.gosavi,
             'GSAVI': self.gsavi,
             'Hue': self.hue,
             'IVI': self.ivi,
             'IPVI': self.ipvi,
             'I': self.i,
             'RVI': self.rvi,
             'MRVI': self.mrvi,
             'MSAVI': self.m_savi,
             'NormG': self.norm_g,
             'NormNIR': self.norm_nir,
             'NormR': self.norm_r,
             'NGRDI': self.ngrdi,
             'RI': self.ri,
             'S': self.s,
             'IF': self._if,
             'DVI': self.dvi,
             'TVI': self.tvi,
             'NDRE': self.ndre,
         }

         try:
               return funcs[index]()
         except KeyError:
               print('Index not in the list!')
               return False


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




         """simple docstring"""

         return -0.18 + (1.17 * ((self.nir - self.red) / (self.nir + self.red)))


   def 			UpperCAmelCase		(						self  :			int)	->				Any:




         """simple docstring"""

         return ((self.nir - self.redEdge) / (self.nir + self.redEdge)) / (
             (self.nir - self.red) / (self.nir + self.red)
         )


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




         """simple docstring"""

         return self.nir * (self.red / (self.green**2))


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




         """simple docstring"""

         return (2 * self.green - self.red - self.blue) / (
             2 * self.green + self.red + self.blue
         )


   def 			UpperCAmelCase		(						self  :			Tuple)	->				Any:




         """simple docstring"""

         return (self.nir - self.red) / (self.nir + self.red)


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




         """simple docstring"""

         return (self.nir - self.blue) / (self.nir + self.blue)


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




         """simple docstring"""

         return (self.redEdge - self.red) / (self.redEdge + self.red)


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




         """simple docstring"""

         return (self.nir - self.green) / (self.nir + self.green)


   def 			UpperCAmelCase		(						self  :			Dict)	->				int:




         """simple docstring"""

         return (self.nir - (self.green + self.blue)) / (
             self.nir + (self.green + self.blue)
         )


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




         """simple docstring"""

         return (self.nir - (self.green + self.red)) / (
             self.nir + (self.green + self.red)
         )


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




         """simple docstring"""

         return (self.nir - (self.blue + self.red)) / (self.nir + (self.blue + self.red))


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




         """simple docstring"""

         return (self.nir - (self.green + self.red + self.blue)) / (
             self.nir + (self.green + self.red + self.blue)
         )


   def 			UpperCAmelCase		(						self  :			Optional[int]			,				lowerCAmelCase  :			List[Any]=0.08			,				lowerCAmelCase  :			Optional[int]=1.22			,				lowerCAmelCase  :			int=0.03)	->				List[Any]:




         """simple docstring"""

         return a * (
             (self.nir - a * self.red - b)
             / (a * self.nir + self.red - a * b + x * (1 + a**2))
         )


   def 			UpperCAmelCase		(						self  :			Tuple)	->				Any:




         """simple docstring"""

         return (0.1 * self.nir - self.blue) / (0.1 * self.nir + self.blue)


   def 			UpperCAmelCase		(						self  :			int)	->				Tuple:




         """simple docstring"""

         return (self.nir / self.green) - 1


   def 			UpperCAmelCase		(						self  :			Any)	->				str:




         """simple docstring"""

         return (self.nir / self.redEdge) - 1


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




         """simple docstring"""

         return (self.red - self.blue) / self.red


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




         """simple docstring"""

         lowercase__     =  self.ndvi()
         return ((ndvi + 0.5) / (abs(ndvi + 0.5))) * (abs(ndvi + 0.5) ** (1 / 2))


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




         """simple docstring"""

         return self.nir - self.green


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




         """simple docstring"""

         return 2.5 * (
             (self.nir - self.red) / (self.nir + 6 * self.red - 7.5 * self.blue + 1)
         )


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




         """simple docstring"""

         lowercase__     =  (2 * (self.nir**2 - self.red**2) + 1.5 * self.nir + 0.5 * self.red) / (
             self.nir + self.red + 0.5
         )
         return n * (1 - 0.25 * n) - (self.red - 0.1_25) / (1 - self.red)


   def 			UpperCAmelCase		(						self  :			int			,				lowerCAmelCase  :			int=0.16)	->				Dict:




         """simple docstring"""

         return (self.nir - self.green) / (self.nir + self.green + y)


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




         """simple docstring"""

         return ((self.nir - self.green) / (self.nir + self.green + n)) * (1 + n)


   def 			UpperCAmelCase		(						self  :			str)	->				int:




         """simple docstring"""

         return np.arctan(
             ((2 * self.red - self.green - self.blue) / 30.5) * (self.green - self.blue))


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




         """simple docstring"""

         return (self.nir - b) / (a * self.red)


   def 			UpperCAmelCase		(						self  :			int)	->				Dict:




         """simple docstring"""

         return (self.nir / ((self.nir + self.red) / 2)) * (self.ndvi() + 1)


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




         """simple docstring"""

         return (self.red + self.green + self.blue) / 30.5


   def 			UpperCAmelCase		(						self  :			int)	->				str:




         """simple docstring"""

         return self.nir / self.red


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




         """simple docstring"""

         return (self.rvi() - 1) / (self.rvi() + 1)


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




         """simple docstring"""

         return (
             (2 * self.nir + 1)
             - ((2 * self.nir + 1) ** 2 - 8 * (self.nir - self.red)) ** (1 / 2)
         ) / 2


   def 			UpperCAmelCase		(						self  :			Tuple)	->				Any:




         """simple docstring"""

         return self.green / (self.nir + self.red + self.green)


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




         """simple docstring"""

         return self.nir / (self.nir + self.red + self.green)


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




         """simple docstring"""

         return self.red / (self.nir + self.red + self.green)


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




         """simple docstring"""

         return (self.green - self.red) / (self.green + self.red)


   def 			UpperCAmelCase		(						self  :			Dict)	->				Tuple:




         """simple docstring"""

         return (self.red - self.green) / (self.red + self.green)


   def 			UpperCAmelCase		(						self  :			str)	->				int:




         """simple docstring"""

         lowercase__     =  np.max([np.max(self.red), np.max(self.green), np.max(self.blue)])
         lowercase__     =  np.min([np.min(self.red), np.min(self.green), np.min(self.blue)])
         return (max_value - min_value) / max_value


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




         """simple docstring"""

         return (2 * self.red - self.green - self.blue) / (self.green - self.blue)


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




         """simple docstring"""

         return self.nir / self.red


   def 			UpperCAmelCase		(						self  :			Dict)	->				Dict:




         """simple docstring"""

         return (self.ndvi() + 0.5) ** (1 / 2)



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




         """simple docstring"""

         return (self.nir - self.redEdge) / (self.nir + self.redEdge)





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)
