






from ..utils import DummyObject, requires_backends





class 						SCREAMING_SNAKE_CASE				( metaclass=snake_case					):





							"""simple docstring"""

							A_						  =					["flax"]

							def __init__(  self:   Any		,     *__A:   Union[str, Any]		,     **__A:   Any   )    ->				Optional[int]:
												requires_backends(self		,     ['''flax''']   )

							@classmethod
							def       __A (  cls:   Dict		,     *__A:   str		,     **__A:   List[Any]   )    ->				Dict:
												requires_backends(cls		,     ['''flax''']   )



							@classmethod
							def       __A (  cls:   Optional[Any]		,     *__A:   List[Any]		,     **__A:   int   )    ->				Any:
												requires_backends(cls		,     ['''flax''']   )





class 						SCREAMING_SNAKE_CASE				( metaclass=snake_case					):





							"""simple docstring"""

							A_						  =					["flax"]

							def __init__(  self:   Dict		,     *__A:   int		,     **__A:   Any   )    ->				Any:
												requires_backends(self		,     ['''flax''']   )

							@classmethod
							def       __A (  cls:   Tuple		,     *__A:   int		,     **__A:   Any   )    ->				str:
												requires_backends(cls		,     ['''flax''']   )



							@classmethod
							def       __A (  cls:   Any		,     *__A:   int		,     **__A:   Optional[int]   )    ->				Any:
												requires_backends(cls		,     ['''flax''']   )





class 						SCREAMING_SNAKE_CASE				( metaclass=snake_case					):





							"""simple docstring"""

							A_						  =					["flax"]

							def __init__(  self:   List[Any]		,     *__A:   Union[str, Any]		,     **__A:   Dict   )    ->				Optional[Any]:
												requires_backends(self		,     ['''flax''']   )

							@classmethod
							def       __A (  cls:   Union[str, Any]		,     *__A:   Dict		,     **__A:   Optional[int]   )    ->				List[Any]:
												requires_backends(cls		,     ['''flax''']   )



							@classmethod
							def       __A (  cls:   Any		,     *__A:   Optional[Any]		,     **__A:   Any   )    ->				Union[str, Any]:
												requires_backends(cls		,     ['''flax''']   )





class 						SCREAMING_SNAKE_CASE				( metaclass=snake_case					):





							"""simple docstring"""

							A_						  =					["flax"]

							def __init__(  self:   Union[str, Any]		,     *__A:   str		,     **__A:   Tuple   )    ->				int:
												requires_backends(self		,     ['''flax''']   )

							@classmethod
							def       __A (  cls:   Union[str, Any]		,     *__A:   Optional[Any]		,     **__A:   List[Any]   )    ->				Tuple:
												requires_backends(cls		,     ['''flax''']   )



							@classmethod
							def       __A (  cls:   str		,     *__A:   Tuple		,     **__A:   List[Any]   )    ->				Optional[int]:
												requires_backends(cls		,     ['''flax''']   )





class 						SCREAMING_SNAKE_CASE				( metaclass=snake_case					):





							"""simple docstring"""

							A_						  =					["flax"]

							def __init__(  self:   Union[str, Any]		,     *__A:   List[str]		,     **__A:   Dict   )    ->				List[Any]:
												requires_backends(self		,     ['''flax''']   )

							@classmethod
							def       __A (  cls:   List[str]		,     *__A:   Any		,     **__A:   int   )    ->				List[Any]:
												requires_backends(cls		,     ['''flax''']   )



							@classmethod
							def       __A (  cls:   Union[str, Any]		,     *__A:   Union[str, Any]		,     **__A:   Any   )    ->				int:
												requires_backends(cls		,     ['''flax''']   )





class 						SCREAMING_SNAKE_CASE				( metaclass=snake_case					):





							"""simple docstring"""

							A_						  =					["flax"]

							def __init__(  self:   List[str]		,     *__A:   Tuple		,     **__A:   int   )    ->				Any:
												requires_backends(self		,     ['''flax''']   )

							@classmethod
							def       __A (  cls:   Dict		,     *__A:   Optional[Any]		,     **__A:   List[str]   )    ->				Any:
												requires_backends(cls		,     ['''flax''']   )



							@classmethod
							def       __A (  cls:   Any		,     *__A:   Dict		,     **__A:   List[Any]   )    ->				Optional[int]:
												requires_backends(cls		,     ['''flax''']   )





class 						SCREAMING_SNAKE_CASE				( metaclass=snake_case					):





							"""simple docstring"""

							A_						  =					["flax"]

							def __init__(  self:   List[Any]		,     *__A:   List[str]		,     **__A:   Dict   )    ->				List[Any]:
												requires_backends(self		,     ['''flax''']   )

							@classmethod
							def       __A (  cls:   int		,     *__A:   Any		,     **__A:   Optional[Any]   )    ->				Optional[Any]:
												requires_backends(cls		,     ['''flax''']   )



							@classmethod
							def       __A (  cls:   Union[str, Any]		,     *__A:   Optional[int]		,     **__A:   Tuple   )    ->				List[Any]:
												requires_backends(cls		,     ['''flax''']   )





class 						SCREAMING_SNAKE_CASE				( metaclass=snake_case					):





							"""simple docstring"""

							A_						  =					["flax"]

							def __init__(  self:   Union[str, Any]		,     *__A:   Any		,     **__A:   List[str]   )    ->				Optional[int]:
												requires_backends(self		,     ['''flax''']   )

							@classmethod
							def       __A (  cls:   int		,     *__A:   int		,     **__A:   int   )    ->				Tuple:
												requires_backends(cls		,     ['''flax''']   )



							@classmethod
							def       __A (  cls:   Dict		,     *__A:   Optional[Any]		,     **__A:   Union[str, Any]   )    ->				Optional[int]:
												requires_backends(cls		,     ['''flax''']   )





class 						SCREAMING_SNAKE_CASE				( metaclass=snake_case					):





							"""simple docstring"""

							A_						  =					["flax"]

							def __init__(  self:   Dict		,     *__A:   List[Any]		,     **__A:   Any   )    ->				List[Any]:
												requires_backends(self		,     ['''flax''']   )

							@classmethod
							def       __A (  cls:   str		,     *__A:   int		,     **__A:   Optional[Any]   )    ->				str:
												requires_backends(cls		,     ['''flax''']   )



							@classmethod
							def       __A (  cls:   Tuple		,     *__A:   List[str]		,     **__A:   Optional[int]   )    ->				Optional[Any]:
												requires_backends(cls		,     ['''flax''']   )





class 						SCREAMING_SNAKE_CASE				( metaclass=snake_case					):





							"""simple docstring"""

							A_						  =					["flax"]

							def __init__(  self:   List[Any]		,     *__A:   Optional[int]		,     **__A:   Union[str, Any]   )    ->				List[str]:
												requires_backends(self		,     ['''flax''']   )

							@classmethod
							def       __A (  cls:   List[Any]		,     *__A:   Any		,     **__A:   List[Any]   )    ->				str:
												requires_backends(cls		,     ['''flax''']   )



							@classmethod
							def       __A (  cls:   int		,     *__A:   List[Any]		,     **__A:   int   )    ->				Any:
												requires_backends(cls		,     ['''flax''']   )





class 						SCREAMING_SNAKE_CASE				( metaclass=snake_case					):





							"""simple docstring"""

							A_						  =					["flax"]

							def __init__(  self:   List[str]		,     *__A:   Tuple		,     **__A:   Optional[Any]   )    ->				Any:
												requires_backends(self		,     ['''flax''']   )

							@classmethod
							def       __A (  cls:   Union[str, Any]		,     *__A:   str		,     **__A:   Dict   )    ->				Optional[Any]:
												requires_backends(cls		,     ['''flax''']   )



							@classmethod
							def       __A (  cls:   Optional[int]		,     *__A:   Optional[Any]		,     **__A:   List[Any]   )    ->				str:
												requires_backends(cls		,     ['''flax''']   )





class 						SCREAMING_SNAKE_CASE				( metaclass=snake_case					):





							"""simple docstring"""

							A_						  =					["flax"]

							def __init__(  self:   List[Any]		,     *__A:   Any		,     **__A:   Any   )    ->				Optional[Any]:
												requires_backends(self		,     ['''flax''']   )

							@classmethod
							def       __A (  cls:   int		,     *__A:   Tuple		,     **__A:   str   )    ->				Dict:
												requires_backends(cls		,     ['''flax''']   )



							@classmethod
							def       __A (  cls:   List[str]		,     *__A:   int		,     **__A:   Tuple   )    ->				Dict:
												requires_backends(cls		,     ['''flax''']   )





class 						SCREAMING_SNAKE_CASE				( metaclass=snake_case					):





							"""simple docstring"""

							A_						  =					["flax"]

							def __init__(  self:   Tuple		,     *__A:   str		,     **__A:   Union[str, Any]   )    ->				List[str]:
												requires_backends(self		,     ['''flax''']   )

							@classmethod
							def       __A (  cls:   int		,     *__A:   List[Any]		,     **__A:   List[str]   )    ->				Union[str, Any]:
												requires_backends(cls		,     ['''flax''']   )



							@classmethod
							def       __A (  cls:   int		,     *__A:   str		,     **__A:   str   )    ->				str:
												requires_backends(cls		,     ['''flax''']   )











from collections import OrderedDict
from typing import Mapping

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


__A      =				logging.get_logger(__name__)

__A      =				{
    'roberta-base': 'https://huggingface.co/roberta-base/resolve/main/config.json',
    'roberta-large': 'https://huggingface.co/roberta-large/resolve/main/config.json',
    'roberta-large-mnli': 'https://huggingface.co/roberta-large-mnli/resolve/main/config.json',
    'distilroberta-base': 'https://huggingface.co/distilroberta-base/resolve/main/config.json',
    'roberta-base-openai-detector': 'https://huggingface.co/roberta-base-openai-detector/resolve/main/config.json',
    'roberta-large-openai-detector': 'https://huggingface.co/roberta-large-openai-detector/resolve/main/config.json',
}





class 						SCREAMING_SNAKE_CASE				( snake_case					):





							"""simple docstring"""

							A_						  =					"roberta"

							def __init__(  self:   Dict		,     __A:   int=5_02_65		,     __A:   Union[str, Any]=7_68		,     __A:   Union[str, Any]=12		,     __A:   str=12		,     __A:   int=30_72		,     __A:   str="gelu"		,     __A:   Union[str, Any]=0.1		,     __A:   int=0.1		,     __A:   Optional[int]=5_12		,     __A:   Union[str, Any]=2		,     __A:   str=0.02		,     __A:   str=1e-12		,     __A:   Any=1		,     __A:   str=0		,     __A:   Any=2		,     __A:   Optional[int]="absolute"		,     __A:   Optional[Any]=True		,     __A:   Union[str, Any]=None		,     **__A:   List[str]		,     )    ->				Dict:
												super().__init__(pad_token_id=__A		,     bos_token_id=__A		,     eos_token_id=__A		,     **__A   )

												_A								= vocab_size
												_A								= hidden_size
												_A								= num_hidden_layers
												_A								= num_attention_heads
												_A								= hidden_act
												_A								= intermediate_size
												_A								= hidden_dropout_prob
												_A								= attention_probs_dropout_prob
												_A								= max_position_embeddings
												_A								= type_vocab_size
												_A								= initializer_range
												_A								= layer_norm_eps
												_A								= position_embedding_type
												_A								= use_cache
												_A								= classifier_dropout





class 						SCREAMING_SNAKE_CASE				( snake_case					):





							"""simple docstring"""

							@property
							def       __A (  self:   Dict   )    ->				Mapping[str, Mapping[int, str]]:
												if self.task == "multiple-choice":
																	_A								= {0: '''batch''', 1: '''choice''', 2: '''sequence'''}
												else:
																	_A								= {0: '''batch''', 1: '''sequence'''}
												return OrderedDict(
												    [
												        ('''input_ids''', dynamic_axis),
												        ('''attention_mask''', dynamic_axis),
												    ]   )



