





'''simple docstring'''



import os
import tempfile
import unittest

from transformers import DistilBertConfig, is_torch_available
from transformers.testing_utils import require_torch, require_torch_gpu, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch

	from transformers import (
	    DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
	    DistilBertForMaskedLM,
	    DistilBertForMultipleChoice,
	    DistilBertForQuestionAnswering,
	    DistilBertForSequenceClassification,
	    DistilBertForTokenClassification,
	    DistilBertModel,
	)






class 							__lowercase    ( a_  ):







	'''simple docstring'''

	def __init__(self       ,_lowerCamelCase       ,_lowerCamelCase=13       ,_lowerCamelCase=7       ,_lowerCamelCase=True       ,_lowerCamelCase=True       ,_lowerCamelCase=False       ,_lowerCamelCase=True       ,_lowerCamelCase=99       ,_lowerCamelCase=32       ,_lowerCamelCase=5       ,_lowerCamelCase=4       ,_lowerCamelCase=37       ,_lowerCamelCase="gelu"       ,_lowerCamelCase=0.1       ,_lowerCamelCase=0.1       ,_lowerCamelCase=512       ,_lowerCamelCase=16       ,_lowerCamelCase=2       ,_lowerCamelCase=0.0_2       ,_lowerCamelCase=3       ,_lowerCamelCase=4       ,_lowerCamelCase=None       ,):







				'''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			  =							hidden_size
				__lowercase			  =							num_hidden_layers
				__lowercase			  =							num_attention_heads
				__lowercase			  =							intermediate_size
				__lowercase			  =							hidden_act
				__lowercase			  =							hidden_dropout_prob
				__lowercase			  =							attention_probs_dropout_prob
				__lowercase			  =							max_position_embeddings
				__lowercase			  =							type_vocab_size
				__lowercase			  =							type_sequence_label_size
				__lowercase			  =							initializer_range
				__lowercase			  =							num_labels
				__lowercase			  =							num_choices
				__lowercase			  =							scope


	def   _UpperCAmelCase       (self	):







				'''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
				__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			  =							self.get_config()

				return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels


	def   _UpperCAmelCase       (self	):







				'''simple docstring'''





				return DistilBertConfig(
				    vocab_size=self.vocab_size       ,dim=self.hidden_size       ,n_layers=self.num_hidden_layers       ,n_heads=self.num_attention_heads       ,hidden_dim=self.intermediate_size       ,hidden_act=self.hidden_act       ,dropout=self.hidden_dropout_prob       ,attention_dropout=self.attention_probs_dropout_prob       ,max_position_embeddings=self.max_position_embeddings       ,initializer_range=self.initializer_range       ,)


	def   _UpperCAmelCase       (self       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase	):







				'''simple docstring'''





				__lowercase			  =							DistilBertModel(config=lowercase_	)
				model.to(lowercase_	)
				model.eval()
				__lowercase			  =							model(lowercase_       ,lowercase_	)
				__lowercase			  =							model(lowercase_	)
				self.parent.assertEqual(result.last_hidden_state.shape       ,(self.batch_size, self.seq_length, self.hidden_size)	)


	def   _UpperCAmelCase       (self       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase	):







				'''simple docstring'''





				__lowercase			  =							DistilBertForMaskedLM(config=lowercase_	)
				model.to(lowercase_	)
				model.eval()
				__lowercase			  =							model(lowercase_       ,attention_mask=lowercase_       ,labels=lowercase_	)
				self.parent.assertEqual(result.logits.shape       ,(self.batch_size, self.seq_length, self.vocab_size)	)


	def   _UpperCAmelCase       (self       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase	):







				'''simple docstring'''





				__lowercase			  =							DistilBertForQuestionAnswering(config=lowercase_	)
				model.to(lowercase_	)
				model.eval()
				__lowercase			  =							model(
				    lowercase_       ,attention_mask=lowercase_       ,start_positions=lowercase_       ,end_positions=lowercase_	)
				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       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase	):







				'''simple docstring'''





				__lowercase			  =							self.num_labels
				__lowercase			  =							DistilBertForSequenceClassification(lowercase_	)
				model.to(lowercase_	)
				model.eval()
				__lowercase			  =							model(lowercase_       ,attention_mask=lowercase_       ,labels=lowercase_	)
				self.parent.assertEqual(result.logits.shape       ,(self.batch_size, self.num_labels)	)


	def   _UpperCAmelCase       (self       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase	):







				'''simple docstring'''





				__lowercase			  =							self.num_labels
				__lowercase			  =							DistilBertForTokenClassification(config=lowercase_	)
				model.to(lowercase_	)
				model.eval()

				__lowercase			  =							model(lowercase_       ,attention_mask=lowercase_       ,labels=lowercase_	)
				self.parent.assertEqual(result.logits.shape       ,(self.batch_size, self.seq_length, self.num_labels)	)


	def   _UpperCAmelCase       (self       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase	):







				'''simple docstring'''





				__lowercase			  =							self.num_choices
				__lowercase			  =							DistilBertForMultipleChoice(config=lowercase_	)
				model.to(lowercase_	)
				model.eval()
				__lowercase			  =							input_ids.unsqueeze(1	).expand(-1       ,self.num_choices       ,-1	).contiguous()
				__lowercase			  =							input_mask.unsqueeze(1	).expand(-1       ,self.num_choices       ,-1	).contiguous()
				__lowercase			  =							model(
				    lowercase_       ,attention_mask=lowercase_       ,labels=lowercase_       ,)
				self.parent.assertEqual(result.logits.shape       ,(self.batch_size, self.num_choices)	)


	def   _UpperCAmelCase       (self	):







				'''simple docstring'''





				__lowercase			  =							self.prepare_config_and_inputs()
				((__lowercase)  ,						(__lowercase)  ,						(__lowercase)  ,						(__lowercase)  ,						(__lowercase)  ,						(__lowercase))			  =							config_and_inputs
				__lowercase			  =							{'''input_ids''': input_ids, '''attention_mask''': input_mask}
				return config, inputs_dict






@require_torch
class 							__lowercase    ( a_	, a_	, unittest.TestCase  ):







	'''simple docstring'''

	a      :			List[Any]     =    (
	    (
	        DistilBertModel,
	        DistilBertForMaskedLM,
	        DistilBertForMultipleChoice,
	        DistilBertForQuestionAnswering,
	        DistilBertForSequenceClassification,
	        DistilBertForTokenClassification,
	    )
	    if is_torch_available()
	    else None
	)
	a      :			Tuple     =    (
	    {
	        '''feature-extraction''': DistilBertModel,
	        '''fill-mask''': DistilBertForMaskedLM,
	        '''question-answering''': DistilBertForQuestionAnswering,
	        '''text-classification''': DistilBertForSequenceClassification,
	        '''token-classification''': DistilBertForTokenClassification,
	        '''zero-shot''': DistilBertForSequenceClassification,
	    }
	    if is_torch_available()
	    else {}
	)
	a      :			str     =    True
	a      :			Optional[int]     =    True
	a      :			Optional[int]     =    True
	a      :			Tuple     =    True


	def   _UpperCAmelCase       (self	):







				'''simple docstring'''





				__lowercase			  =							DistilBertModelTester(self	)
				__lowercase			  =							ConfigTester(self       ,config_class=lowercase_       ,dim=37	)


	def   _UpperCAmelCase       (self	):







				'''simple docstring'''





				self.config_tester.run_common_tests()


	def   _UpperCAmelCase       (self	):







				'''simple docstring'''





				__lowercase			  =							self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_distilbert_model(*lowercase_	)


	def   _UpperCAmelCase       (self	):







				'''simple docstring'''





				__lowercase			  =							self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_distilbert_for_masked_lm(*lowercase_	)


	def   _UpperCAmelCase       (self	):







				'''simple docstring'''





				__lowercase			  =							self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_distilbert_for_question_answering(*lowercase_	)


	def   _UpperCAmelCase       (self	):







				'''simple docstring'''





				__lowercase			  =							self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_distilbert_for_sequence_classification(*lowercase_	)


	def   _UpperCAmelCase       (self	):







				'''simple docstring'''





				__lowercase			  =							self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_distilbert_for_token_classification(*lowercase_	)


	def   _UpperCAmelCase       (self	):







				'''simple docstring'''





				__lowercase			  =							self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_distilbert_for_multiple_choice(*lowercase_	)


	@slow
	def   _UpperCAmelCase       (self	):







				'''simple docstring'''





				for model_name in DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							__lowercase			  =							DistilBertModel.from_pretrained(lowercase_	)
							self.assertIsNotNone(lowercase_	)


	@slow
	@require_torch_gpu
	def   _UpperCAmelCase       (self	):







				'''simple docstring'''





				__lowercase  ,						__lowercase			  =							self.model_tester.prepare_config_and_inputs_for_common()
				for model_class in self.all_model_classes:
							# BertForMultipleChoice behaves incorrectly in JIT environments.
							if model_class == DistilBertForMultipleChoice:
										return

							__lowercase			  =							True
							__lowercase			  =							model_class(config=lowercase_	)

							__lowercase			  =							self._prepare_for_class(lowercase_       ,lowercase_	)
							__lowercase			  =							torch.jit.trace(
							    lowercase_       ,(inputs_dict['''input_ids'''].to('''cpu'''	), inputs_dict['''attention_mask'''].to('''cpu'''	))	)

							with tempfile.TemporaryDirectory() as tmp:
										torch.jit.save(lowercase_       ,os.path.join(lowercase_       ,'''traced_model.pt'''	)	)
										__lowercase			  =							torch.jit.load(os.path.join(lowercase_       ,'''traced_model.pt'''	)       ,map_location=lowercase_	)
										loaded(inputs_dict['''input_ids'''].to(lowercase_	)       ,inputs_dict['''attention_mask'''].to(lowercase_	)	)






@require_torch
class 							__lowercase    ( unittest.TestCase  ):







	'''simple docstring'''

	@slow
	def   _UpperCAmelCase       (self	):







				'''simple docstring'''





				__lowercase			  =							DistilBertModel.from_pretrained('''distilbert-base-uncased'''	)
				__lowercase			  =							torch.tensor([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]]	)
				__lowercase			  =							torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]	)
				with torch.no_grad():
							__lowercase			  =							model(lowercase_       ,attention_mask=lowercase_	)[0]
				__lowercase			  =							torch.Size((1, 11, 768)	)
				self.assertEqual(output.shape       ,lowercase_	)
				__lowercase			  =							torch.tensor(
				    [[[-0.1_6_3_9, 0.3_2_9_9, 0.1_6_4_8], [-0.1_7_4_6, 0.3_2_8_9, 0.1_7_1_0], [-0.1_8_8_4, 0.3_3_5_7, 0.1_8_1_0]]]	)

				self.assertTrue(torch.allclose(output[:, 1:4, 1:4]       ,lowercase_       ,atol=1E-4	)	)












'''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


_SCREAMING_SNAKE_CASE   =      {'''vocab_file''': '''vocab.txt''', '''tokenizer_file''': '''tokenizer.json'''}

_SCREAMING_SNAKE_CASE   =      {
    '''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'''
        ),
    },
}

_SCREAMING_SNAKE_CASE   =      {
    '''google/electra-small-generator''': 5_1_2,
    '''google/electra-base-generator''': 5_1_2,
    '''google/electra-large-generator''': 5_1_2,
    '''google/electra-small-discriminator''': 5_1_2,
    '''google/electra-base-discriminator''': 5_1_2,
    '''google/electra-large-discriminator''': 5_1_2,
}

_SCREAMING_SNAKE_CASE   =      {
    '''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 							__lowercase    ( lowerCAmelCase__  ):







	'''simple docstring'''

	a      :			str     =    VOCAB_FILES_NAMES
	a      :			Dict     =    PRETRAINED_VOCAB_FILES_MAP
	a      :			int     =    PRETRAINED_INIT_CONFIGURATION
	a      :			Tuple     =    PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
	a      :			List[Any]     =    ElectraTokenizer


	def __init__(self       ,_lowerCamelCase=None       ,_lowerCamelCase=None       ,_lowerCamelCase=True       ,_lowerCamelCase="[UNK]"       ,_lowerCamelCase="[SEP]"       ,_lowerCamelCase="[PAD]"       ,_lowerCamelCase="[CLS]"       ,_lowerCamelCase="[MASK]"       ,_lowerCamelCase=True       ,_lowerCamelCase=None       ,**_lowerCamelCase       ,)							->							List[Any]:







				'''simple docstring'''





				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       ,)

				__lowercase			  =							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
				):
							__lowercase			  =							getattr(_lowerCamelCase       ,normalizer_state.pop('''type'''	)	)
							__lowercase			  =							do_lower_case
							__lowercase			  =							strip_accents
							__lowercase			  =							tokenize_chinese_chars
							__lowercase			  =							normalizer_class(**_lowerCamelCase	)

				__lowercase			  =							do_lower_case


	def   _UpperCAmelCase       (self       ,_lowerCamelCase       ,_lowerCamelCase=None	)							->							str:







				'''simple docstring'''





				__lowercase			  =							[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   _UpperCAmelCase       (self       ,_lowerCamelCase       ,_lowerCamelCase = None	)							->							List[int]:







				'''simple docstring'''





				__lowercase			  =							[self.sep_token_id]
				__lowercase			  =							[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   _UpperCAmelCase       (self       ,_lowerCamelCase       ,_lowerCamelCase = None	)							->							Tuple[str]:







				'''simple docstring'''





				__lowercase			  =							self._tokenizer.model.save(_lowerCamelCase       ,name=_lowerCamelCase	)
				return tuple(_lowerCamelCase	)





