


"""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      __A     (snake_case__):





							'''simple docstring'''

							def __init__(				self							:      Optional[Any]		,       UpperCAmelCase_							:      Optional[int]		,       UpperCAmelCase_							:      int=13		,       UpperCAmelCase_							:      List[str]=7		,       UpperCAmelCase_							:      Tuple=True		,       UpperCAmelCase_							:      int=True		,       UpperCAmelCase_							:      List[str]=False		,       UpperCAmelCase_							:      Tuple=True		,       UpperCAmelCase_							:      Union[str, Any]=99		,       UpperCAmelCase_							:      str=32		,       UpperCAmelCase_							:      int=5		,       UpperCAmelCase_							:      Union[str, Any]=4		,       UpperCAmelCase_							:      str=37		,       UpperCAmelCase_							:      Optional[Any]="gelu"		,       UpperCAmelCase_							:      List[Any]=0.1		,       UpperCAmelCase_							:      Optional[Any]=0.1		,       UpperCAmelCase_							:      Optional[int]=512		,       UpperCAmelCase_							:      Union[str, Any]=16		,       UpperCAmelCase_							:      Optional[Any]=2		,       UpperCAmelCase_							:      Tuple=0.02		,       UpperCAmelCase_							:      int=3		,       UpperCAmelCase_							:      List[Any]=4		,       UpperCAmelCase_							:      List[Any]=None		,       )					->Any:



														"""simple docstring"""



														snake_case_           =		parent
														snake_case_           =		batch_size
														snake_case_           =		seq_length
														snake_case_           =		is_training
														snake_case_           =		use_input_mask
														snake_case_           =		use_token_type_ids
														snake_case_           =		use_labels
														snake_case_           =		vocab_size
														snake_case_           =		hidden_size
														snake_case_           =		num_hidden_layers
														snake_case_           =		num_attention_heads
														snake_case_           =		intermediate_size
														snake_case_           =		hidden_act
														snake_case_           =		hidden_dropout_prob
														snake_case_           =		attention_probs_dropout_prob
														snake_case_           =		max_position_embeddings
														snake_case_           =		type_vocab_size
														snake_case_           =		type_sequence_label_size
														snake_case_           =		initializer_range
														snake_case_           =		num_labels
														snake_case_           =		num_choices
														snake_case_           =		scope



							def 		lowerCAmelCase       (				self							:      Tuple       )					->int:



														"""simple docstring"""



														snake_case_           =		ids_tensor([self.batch_size, self.seq_length]		,       self.vocab_size       )

														snake_case_           =		None
														if self.use_input_mask:
																					snake_case_           =		random_attention_mask([self.batch_size, self.seq_length]       )

														snake_case_           =		None
														snake_case_           =		None
														snake_case_           =		None
														if self.use_labels:
																					snake_case_           =		ids_tensor([self.batch_size]		,       self.type_sequence_label_size       )
																					snake_case_           =		ids_tensor([self.batch_size, self.seq_length]		,       self.num_labels       )
																					snake_case_           =		ids_tensor([self.batch_size]		,       self.num_choices       )

														snake_case_           =		self.get_config()

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



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



														"""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 		lowerCAmelCase       (				self							:      Optional[Any]		,       UpperCAmelCase_							:      List[str]		,       UpperCAmelCase_							:      int		,       UpperCAmelCase_							:      Union[str, Any]		,       UpperCAmelCase_							:      Union[str, Any]		,       UpperCAmelCase_							:      List[str]		,       UpperCAmelCase_							:      Tuple       )					->List[str]:



														"""simple docstring"""



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



							def 		lowerCAmelCase       (				self							:      Dict		,       UpperCAmelCase_							:      Optional[int]		,       UpperCAmelCase_							:      Optional[Any]		,       UpperCAmelCase_							:      Any		,       UpperCAmelCase_							:      List[Any]		,       UpperCAmelCase_							:      Optional[Any]		,       UpperCAmelCase_							:      Tuple       )					->int:



														"""simple docstring"""



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



							def 		lowerCAmelCase       (				self							:      int		,       UpperCAmelCase_							:      List[Any]		,       UpperCAmelCase_							:      int		,       UpperCAmelCase_							:      Tuple		,       UpperCAmelCase_							:      Union[str, Any]		,       UpperCAmelCase_							:      int		,       UpperCAmelCase_							:      Any       )					->Optional[Any]:



														"""simple docstring"""



														snake_case_           =		DistilBertForQuestionAnswering(config=UpperCAmelCase_       )
														model.to(UpperCAmelCase_       )
														model.eval()
														snake_case_           =		model(
														    UpperCAmelCase_		,       attention_mask=UpperCAmelCase_		,       start_positions=UpperCAmelCase_		,       end_positions=UpperCAmelCase_       )
														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 		lowerCAmelCase       (				self							:      Union[str, Any]		,       UpperCAmelCase_							:      Dict		,       UpperCAmelCase_							:      Union[str, Any]		,       UpperCAmelCase_							:      Optional[int]		,       UpperCAmelCase_							:      List[str]		,       UpperCAmelCase_							:      List[str]		,       UpperCAmelCase_							:      Tuple       )					->Dict:



														"""simple docstring"""



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



							def 		lowerCAmelCase       (				self							:      List[Any]		,       UpperCAmelCase_							:      List[str]		,       UpperCAmelCase_							:      List[str]		,       UpperCAmelCase_							:      List[Any]		,       UpperCAmelCase_							:      Union[str, Any]		,       UpperCAmelCase_							:      Union[str, Any]		,       UpperCAmelCase_							:      Optional[int]       )					->Dict:



														"""simple docstring"""



														snake_case_           =		self.num_labels
														snake_case_           =		DistilBertForTokenClassification(config=UpperCAmelCase_       )
														model.to(UpperCAmelCase_       )
														model.eval()

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



							def 		lowerCAmelCase       (				self							:      Optional[Any]		,       UpperCAmelCase_							:      int		,       UpperCAmelCase_							:      Tuple		,       UpperCAmelCase_							:      List[Any]		,       UpperCAmelCase_							:      Tuple		,       UpperCAmelCase_							:      int		,       UpperCAmelCase_							:      Optional[Any]       )					->Tuple:



														"""simple docstring"""



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



							def 		lowerCAmelCase       (				self							:      Optional[Any]       )					->Tuple:



														"""simple docstring"""



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





@require_torch
class      __A     (snake_case__						,		snake_case__						,		unittest.TestCase):





							'''simple docstring'''

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



							def 		lowerCAmelCase       (				self							:      Tuple       )					->List[str]:



														"""simple docstring"""



														snake_case_           =		DistilBertModelTester(self       )
														snake_case_           =		ConfigTester(self		,       config_class=UpperCAmelCase_		,       dim=37       )



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



														"""simple docstring"""



														self.config_tester.run_common_tests()



							def 		lowerCAmelCase       (				self							:      Any       )					->Any:



														"""simple docstring"""



														snake_case_           =		self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_distilbert_model(*UpperCAmelCase_       )



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



														"""simple docstring"""



														snake_case_           =		self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_distilbert_for_masked_lm(*UpperCAmelCase_       )



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



														"""simple docstring"""



														snake_case_           =		self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_distilbert_for_question_answering(*UpperCAmelCase_       )



							def 		lowerCAmelCase       (				self							:      str       )					->Any:



														"""simple docstring"""



														snake_case_           =		self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_distilbert_for_sequence_classification(*UpperCAmelCase_       )



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



														"""simple docstring"""



														snake_case_           =		self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_distilbert_for_token_classification(*UpperCAmelCase_       )



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



														"""simple docstring"""



														snake_case_           =		self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_distilbert_for_multiple_choice(*UpperCAmelCase_       )



							@slow
							def 		lowerCAmelCase       (				self							:      Any       )					->Union[str, Any]:



														"""simple docstring"""



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



							@slow
							@require_torch_gpu
							def 		lowerCAmelCase       (				self							:      Union[str, Any]       )					->Dict:



														"""simple docstring"""



														snake_case_       ,						snake_case_           =		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

																					snake_case_           =		True
																					snake_case_           =		model_class(config=UpperCAmelCase_       )

																					snake_case_           =		self._prepare_for_class(UpperCAmelCase_		,       UpperCAmelCase_       )
																					snake_case_           =		torch.jit.trace(
																					    UpperCAmelCase_		,       (inputs_dict["""input_ids"""].to("""cpu"""       ), inputs_dict["""attention_mask"""].to("""cpu"""       ))       )

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





@require_torch
class      __A     (unittest.TestCase):





							'''simple docstring'''

							@slow
							def 		lowerCAmelCase       (				self							:      Optional[Any]       )					->List[Any]:



														"""simple docstring"""



														snake_case_           =		DistilBertModel.from_pretrained("""distilbert-base-uncased"""       )
														snake_case_           =		torch.tensor([[0, 345, 232, 328, 740, 140, 1_695, 69, 6_078, 1_588, 2]]       )
														snake_case_           =		torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]       )
														with torch.no_grad():
																					snake_case_           =		model(UpperCAmelCase_		,       attention_mask=UpperCAmelCase_       )[0]
														snake_case_           =		torch.Size((1, 11, 768)       )
														self.assertEqual(output.shape		,       UpperCAmelCase_       )
														snake_case_           =		torch.tensor(
														    [[[-0.1_639, 0.3_299, 0.1_648], [-0.1_746, 0.3_289, 0.1_710], [-0.1_884, 0.3_357, 0.1_810]]]       )

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







"""simple docstring"""
__SCREAMING_SNAKE_CASE							:    str		=    'Input must be a string of 8 numbers plus letter'
__SCREAMING_SNAKE_CASE							:    Dict		=    'TRWAGMYFPDXBNJZSQVHLCKE'







def 						_a				(      _SCREAMING_SNAKE_CASE				)    ->				bool:

							if not isinstance(_SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				):
														snake_case_           =		f"""Expected string as input, found {type(_SCREAMING_SNAKE_CASE				).__name__}"""
														raise TypeError(_SCREAMING_SNAKE_CASE				)

							snake_case_           =		spanish_id.replace("""-"""				, """"""				).upper()
							if len(_SCREAMING_SNAKE_CASE				) != 9:
														raise ValueError(_SCREAMING_SNAKE_CASE				)

							try:
														snake_case_           =		int(spanish_id_clean[0:8]				)
														snake_case_           =		spanish_id_clean[8]
							except ValueError as ex:
														raise ValueError(_SCREAMING_SNAKE_CASE				) from ex

							if letter.isdigit():
														raise ValueError(_SCREAMING_SNAKE_CASE				)

							return letter == LOOKUP_LETTERS[number % 23]


if __name__ == "__main__":
				import doctest

				doctest.testmod()



