


class _lowerCAmelCase       :







   def __init__(			self		,			UpperCamelCase__		)			->	Optional[int]:

       '''simple docstring'''




       snake_case					:   str         =					set_counts
       snake_case					:   Dict         =					max(UpperCamelCase__		)
       snake_case					:   Any         =					len(UpperCamelCase__		)
       snake_case					:   str         =					[1] * num_sets
       snake_case					:   str         =					list(range(UpperCamelCase__		)		)







   def 				lowerCamelCase	(			self		,			UpperCamelCase__		,			UpperCamelCase__		)			->	Tuple:

       '''simple docstring'''




       snake_case					:   Optional[int]         =					self.get_parent(UpperCamelCase__		)
       snake_case					:   Any         =					self.get_parent(UpperCamelCase__		)

       if src_parent == dst_parent:
           return False

       if self.ranks[dst_parent] >= self.ranks[src_parent]:
           self.set_counts[dst_parent] += self.set_counts[src_parent]
           snake_case					:   int         =					0
           snake_case					:   Optional[int]         =					dst_parent
           if self.ranks[dst_parent] == self.ranks[src_parent]:
               self.ranks[dst_parent] += 1
           snake_case					:   int         =					self.set_counts[dst_parent]
       else:
           self.set_counts[src_parent] += self.set_counts[dst_parent]
           snake_case					:   Optional[Any]         =					0
           snake_case					:   Dict         =					src_parent
           snake_case					:   Any         =					self.set_counts[src_parent]

       snake_case					:   Optional[int]         =					max(self.max_set		,			UpperCamelCase__		)
       return True







   def 				lowerCamelCase	(			self		,			UpperCamelCase__		)			->	int:

       '''simple docstring'''




       if self.parents[disj_set] == disj_set:
           return disj_set
       snake_case					:   Dict         =					self.get_parent(self.parents[disj_set]		)
       return self.parents[disj_set]









"""simple docstring"""



from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


__snake_case         =					logging.get_logger(__name__)

__snake_case         =					{
    """google/bigbird-roberta-base""": """https://huggingface.co/google/bigbird-roberta-base/resolve/main/config.json""",
    """google/bigbird-roberta-large""": """https://huggingface.co/google/bigbird-roberta-large/resolve/main/config.json""",
    """google/bigbird-base-trivia-itc""": """https://huggingface.co/google/bigbird-base-trivia-itc/resolve/main/config.json""",
    # See all BigBird models at https://huggingface.co/models?filter=big_bird
}







class _lowerCAmelCase       (   snake_case_			):
   __UpperCAmelCase				: Optional[Any]													=						'''big_bird'''







   def __init__(			self		,			UpperCamelCase__=5_0358		,			UpperCamelCase__=768		,			UpperCamelCase__=12		,			UpperCamelCase__=12		,			UpperCamelCase__=3072		,			UpperCamelCase__="gelu_new"		,			UpperCamelCase__=0.1		,			UpperCamelCase__=0.1		,			UpperCamelCase__=4096		,			UpperCamelCase__=2		,			UpperCamelCase__=0.02		,			UpperCamelCase__=1e-12		,			UpperCamelCase__=True		,			UpperCamelCase__=0		,			UpperCamelCase__=1		,			UpperCamelCase__=2		,			UpperCamelCase__=66		,			UpperCamelCase__="block_sparse"		,			UpperCamelCase__=True		,			UpperCamelCase__=False		,			UpperCamelCase__=64		,			UpperCamelCase__=3		,			UpperCamelCase__=None		,			**UpperCamelCase__		,			)			->	Tuple:

       '''simple docstring'''




       super().__init__(
           pad_token_id=UpperCamelCase__		,			bos_token_id=UpperCamelCase__		,			eos_token_id=UpperCamelCase__		,			sep_token_id=UpperCamelCase__		,			**UpperCamelCase__		,			)

       snake_case					:   Union[str, Any]         =					vocab_size
       snake_case					:   List[Any]         =					max_position_embeddings
       snake_case					:   int         =					hidden_size
       snake_case					:   str         =					num_hidden_layers
       snake_case					:   Any         =					num_attention_heads
       snake_case					:   int         =					intermediate_size
       snake_case					:   Union[str, Any]         =					hidden_act
       snake_case					:   Optional[Any]         =					hidden_dropout_prob
       snake_case					:   List[Any]         =					attention_probs_dropout_prob
       snake_case					:   int         =					initializer_range
       snake_case					:   List[str]         =					type_vocab_size
       snake_case					:   Optional[Any]         =					layer_norm_eps
       snake_case					:   Optional[Any]         =					use_cache

       snake_case					:   List[Any]         =					rescale_embeddings
       snake_case					:   Any         =					attention_type
       snake_case					:   List[Any]         =					use_bias
       snake_case					:   int         =					block_size
       snake_case					:   int         =					num_random_blocks
       snake_case					:   Optional[int]         =					classifier_dropout







class _lowerCAmelCase       (   snake_case_			):







   @property
   def 				lowerCamelCase	(			self		)			->	Mapping[str, Mapping[int, str]]:

       '''simple docstring'''




       if self.task == "multiple-choice":
           snake_case					:   int         =					{0: "batch", 1: "choice", 2: "sequence"}
       else:
           snake_case					:   Optional[Any]         =					{0: "batch", 1: "sequence"}
       return OrderedDict(
           [
               ("input_ids", dynamic_axis),
               ("attention_mask", dynamic_axis),
           ]		)





