


from typing import Optional, Union

import torch
from torch import nn

from ...configuration_utils import ConfigMixin, register_to_config
from ...models.modeling_utils import ModelMixin






class      UpperCamelCase(	UpperCAmelCase__  ,				UpperCAmelCase__ ):


					@register_to_config
					def __init__(    self						:		Dict  ,     SCREAMING_SNAKE_CASE						:		int = 7_6_8  ,     )      ->						Dict:




											'''simple docstring'''

											super().__init__()

											__snake_case				=		nn.Parameter(torch.zeros(1  ,     __lowerCAmelCase    )    )
											__snake_case				=		nn.Parameter(torch.ones(1  ,     __lowerCAmelCase    )    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		int  ,     SCREAMING_SNAKE_CASE						:		Optional[Union[str, torch.device]] = None  ,     SCREAMING_SNAKE_CASE						:		Optional[torch.dtype] = None  ,     )      ->						List[Any]:




											'''simple docstring'''

											__snake_case				=		nn.Parameter(self.mean.to(__lowerCAmelCase    ).to(__lowerCAmelCase    )    )
											__snake_case				=		nn.Parameter(self.std.to(__lowerCAmelCase    ).to(__lowerCAmelCase    )    )
											return self


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




											'''simple docstring'''

											__snake_case				=		(embeds - self.mean) * 1.0 / self.std
											return embeds






					def 				SCREAMING_SNAKE_CASE_	(    self						:		str  ,     SCREAMING_SNAKE_CASE						:		List[str]    )      ->						Any:




											'''simple docstring'''

											__snake_case				=		(embeds * self.std) + self.mean
											return embeds











'''simple docstring'''


import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from .tokenization_electra import ElectraTokenizer


_lowercase  =			{"""vocab_file""": """vocab.txt""", """tokenizer_file""": """tokenizer.json"""}

_lowercase  =			{
    """vocab_file""": {
        """google/electra-small-generator""": (
            """https://huggingface.co/google/electra-small-generator/resolve/main/vocab.txt"""
        ),
        """google/electra-base-generator""": """https://huggingface.co/google/electra-base-generator/resolve/main/vocab.txt""",
        """google/electra-large-generator""": (
            """https://huggingface.co/google/electra-large-generator/resolve/main/vocab.txt"""
        ),
        """google/electra-small-discriminator""": (
            """https://huggingface.co/google/electra-small-discriminator/resolve/main/vocab.txt"""
        ),
        """google/electra-base-discriminator""": (
            """https://huggingface.co/google/electra-base-discriminator/resolve/main/vocab.txt"""
        ),
        """google/electra-large-discriminator""": (
            """https://huggingface.co/google/electra-large-discriminator/resolve/main/vocab.txt"""
        ),
    },
    """tokenizer_file""": {
        """google/electra-small-generator""": (
            """https://huggingface.co/google/electra-small-generator/resolve/main/tokenizer.json"""
        ),
        """google/electra-base-generator""": (
            """https://huggingface.co/google/electra-base-generator/resolve/main/tokenizer.json"""
        ),
        """google/electra-large-generator""": (
            """https://huggingface.co/google/electra-large-generator/resolve/main/tokenizer.json"""
        ),
        """google/electra-small-discriminator""": (
            """https://huggingface.co/google/electra-small-discriminator/resolve/main/tokenizer.json"""
        ),
        """google/electra-base-discriminator""": (
            """https://huggingface.co/google/electra-base-discriminator/resolve/main/tokenizer.json"""
        ),
        """google/electra-large-discriminator""": (
            """https://huggingface.co/google/electra-large-discriminator/resolve/main/tokenizer.json"""
        ),
    },
}

_lowercase  =			{
    """google/electra-small-generator""": 5_12,
    """google/electra-base-generator""": 5_12,
    """google/electra-large-generator""": 5_12,
    """google/electra-small-discriminator""": 5_12,
    """google/electra-base-discriminator""": 5_12,
    """google/electra-large-discriminator""": 5_12,
}

_lowercase  =			{
    """google/electra-small-generator""": {"""do_lower_case""": True},
    """google/electra-base-generator""": {"""do_lower_case""": True},
    """google/electra-large-generator""": {"""do_lower_case""": True},
    """google/electra-small-discriminator""": {"""do_lower_case""": True},
    """google/electra-base-discriminator""": {"""do_lower_case""": True},
    """google/electra-large-discriminator""": {"""do_lower_case""": True},
}
class 						a_				(			UpperCAmelCase__						):
	lowercase_       :     Tuple			  =      VOCAB_FILES_NAMES
	lowercase_       :     Optional[int]			  =      PRETRAINED_VOCAB_FILES_MAP
	lowercase_       :     int			  =      PRETRAINED_INIT_CONFIGURATION
	lowercase_       :     str			  =      PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
	lowercase_       :     List[Any]			  =      ElectraTokenizer




	def __init__(       self     :  Optional[Any]       ,		__lowerCAmelCase     :  Optional[Any]=None       ,		__lowerCAmelCase     :  str=None       ,		__lowerCAmelCase     :  Union[str, Any]=True       ,		__lowerCAmelCase     :  int="[UNK]"       ,		__lowerCAmelCase     :  str="[SEP]"       ,		__lowerCAmelCase     :  Optional[Any]="[PAD]"       ,		__lowerCAmelCase     :  Optional[Any]="[CLS]"       ,		__lowerCAmelCase     :  str="[MASK]"       ,		__lowerCAmelCase     :  List[Any]=True       ,		__lowerCAmelCase     :  Optional[int]=None       ,		**__lowerCAmelCase     :  List[Any]       ,		):
							super().__init__(
							    __lowerCAmelCase       ,		tokenizer_file=__lowerCAmelCase       ,		do_lower_case=__lowerCAmelCase       ,		unk_token=__lowerCAmelCase       ,		sep_token=__lowerCAmelCase       ,		pad_token=__lowerCAmelCase       ,		cls_token=__lowerCAmelCase       ,		mask_token=__lowerCAmelCase       ,		tokenize_chinese_chars=__lowerCAmelCase       ,		strip_accents=__lowerCAmelCase       ,		**__lowerCAmelCase       ,		)

							__snake_case						 =   json.loads(self.backend_tokenizer.normalizer.__getstate__()      )
							if (
							    normalizer_state.get('lowercase'       ,		__lowerCAmelCase      ) != do_lower_case
							    or normalizer_state.get('strip_accents'       ,		__lowerCAmelCase      ) != strip_accents
							    or normalizer_state.get('handle_chinese_chars'       ,		__lowerCAmelCase      ) != tokenize_chinese_chars
							):
													__snake_case						 =   getattr(__lowerCAmelCase       ,		normalizer_state.pop('type'      )      )
													__snake_case						 =   do_lower_case
													__snake_case						 =   strip_accents
													__snake_case						 =   tokenize_chinese_chars
													__snake_case						 =   normalizer_class(**__lowerCAmelCase      )

							__snake_case						 =   do_lower_case




	def   lowercase__   (       self     :  Union[str, Any]       ,		__lowerCAmelCase     :  str       ,		__lowerCAmelCase     :  Tuple=None      ):
							__snake_case						 =   [self.cls_token_id] + token_ids_a + [self.sep_token_id]

							if token_ids_a:
													output += token_ids_a + [self.sep_token_id]

							return output




	def   lowercase__   (       self     :  Any       ,		__lowerCAmelCase     :  List[int]       ,		__lowerCAmelCase     :  Optional[List[int]] = None      ):
							__snake_case						 =   [self.sep_token_id]
							__snake_case						 =   [self.cls_token_id]
							if token_ids_a is None:
													return len(cls + token_ids_a + sep      ) * [0]
							return len(cls + token_ids_a + sep      ) * [0] + len(token_ids_a + sep      ) * [1]




	def   lowercase__   (       self     :  List[Any]       ,		__lowerCAmelCase     :  str       ,		__lowerCAmelCase     :  Optional[str] = None      ):
							__snake_case						 =   self._tokenizer.model.save(__lowerCAmelCase       ,		name=__lowerCAmelCase      )
							return tuple(__lowerCAmelCase      )

