



'''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 _UpperCamelCase		(     A		):





				'''simple docstring'''





				def __init__(							self  :  List[Any]  ,       _lowerCAmelCase  :  List[Any]  ,       _lowerCAmelCase  :  Optional[Any]=1_3  ,       _lowerCAmelCase  :  Dict=7  ,       _lowerCAmelCase  :  str=True  ,       _lowerCAmelCase  :  str=True  ,       _lowerCAmelCase  :  int=False  ,       _lowerCAmelCase  :  Union[str, Any]=True  ,       _lowerCAmelCase  :  Tuple=9_9  ,       _lowerCAmelCase  :  Any=3_2  ,       _lowerCAmelCase  :  int=5  ,       _lowerCAmelCase  :  int=4  ,       _lowerCAmelCase  :  Any=3_7  ,       _lowerCAmelCase  :  Tuple="gelu"  ,       _lowerCAmelCase  :  int=0.1  ,       _lowerCAmelCase  :  Union[str, Any]=0.1  ,       _lowerCAmelCase  :  Optional[Any]=5_1_2  ,       _lowerCAmelCase  :  int=1_6  ,       _lowerCAmelCase  :  Tuple=2  ,       _lowerCAmelCase  :  List[str]=0.02  ,       _lowerCAmelCase  :  Tuple=3  ,       _lowerCAmelCase  :  Dict=4  ,       _lowerCAmelCase  :  Any=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 				__lowerCamelCase     (							self  :  List[Any]):







											'''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 				__lowerCamelCase     (							self  :  Optional[int]):







											'''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  :  str  ,       _lowerCAmelCase  :  List[Any]  ,       _lowerCAmelCase  :  Union[str, Any]  ,       _lowerCAmelCase  :  Union[str, Any]  ,       _lowerCAmelCase  :  str  ,       _lowerCAmelCase  :  str  ,       _lowerCAmelCase  :  List[Any]):







											'''simple docstring'''

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

				def 				__lowerCamelCase     (							self  :  Optional[Any]  ,       _lowerCAmelCase  :  int  ,       _lowerCAmelCase  :  int  ,       _lowerCAmelCase  :  Optional[int]  ,       _lowerCAmelCase  :  int  ,       _lowerCAmelCase  :  int  ,       _lowerCAmelCase  :  Dict):







											'''simple docstring'''

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

				def 				__lowerCamelCase     (							self  :  Any  ,       _lowerCAmelCase  :  int  ,       _lowerCAmelCase  :  Any  ,       _lowerCAmelCase  :  str  ,       _lowerCAmelCase  :  Dict  ,       _lowerCAmelCase  :  str  ,       _lowerCAmelCase  :  Optional[Any]):







											'''simple docstring'''

											__lowercase       	=DistilBertForQuestionAnswering(config=_lowerCAmelCase)
											model.to(_lowerCAmelCase)
											model.eval()
											__lowercase       	=model(
											    _lowerCAmelCase  ,       attention_mask=_lowerCAmelCase  ,       start_positions=_lowerCAmelCase  ,       end_positions=_lowerCAmelCase)
											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]  ,       _lowerCAmelCase  :  Dict  ,       _lowerCAmelCase  :  Union[str, Any]  ,       _lowerCAmelCase  :  Tuple  ,       _lowerCAmelCase  :  Union[str, Any]  ,       _lowerCAmelCase  :  Dict  ,       _lowerCAmelCase  :  str):







											'''simple docstring'''

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

				def 				__lowerCamelCase     (							self  :  Dict  ,       _lowerCAmelCase  :  List[str]  ,       _lowerCAmelCase  :  Any  ,       _lowerCAmelCase  :  Dict  ,       _lowerCAmelCase  :  Optional[Any]  ,       _lowerCAmelCase  :  Union[str, Any]  ,       _lowerCAmelCase  :  str):







											'''simple docstring'''

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

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

				def 				__lowerCamelCase     (							self  :  Any  ,       _lowerCAmelCase  :  Any  ,       _lowerCAmelCase  :  List[str]  ,       _lowerCAmelCase  :  List[str]  ,       _lowerCAmelCase  :  str  ,       _lowerCAmelCase  :  int  ,       _lowerCAmelCase  :  Optional[Any]):







											'''simple docstring'''

											__lowercase       	=self.num_choices
											__lowercase       	=DistilBertForMultipleChoice(config=_lowerCAmelCase)
											model.to(_lowerCAmelCase)
											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(
											    _lowerCAmelCase  ,       attention_mask=_lowerCAmelCase  ,       labels=_lowerCAmelCase  ,       )
											self.parent.assertEqual(result.logits.shape  ,       (self.batch_size, self.num_choices))

				def 				__lowerCamelCase     (							self  :  Union[str, Any]):







											'''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 _UpperCamelCase		(     A      ,       A      ,       unittest.TestCase		):





				'''simple docstring'''





				lowerCAmelCase__					    =    (
				    (
				        DistilBertModel,
				        DistilBertForMaskedLM,
				        DistilBertForMultipleChoice,
				        DistilBertForQuestionAnswering,
				        DistilBertForSequenceClassification,
				        DistilBertForTokenClassification,
				    )
				    if is_torch_available()
				    else None
				)
				lowerCAmelCase__					    =    (
				    {
				        """feature-extraction""": DistilBertModel,
				        """fill-mask""": DistilBertForMaskedLM,
				        """question-answering""": DistilBertForQuestionAnswering,
				        """text-classification""": DistilBertForSequenceClassification,
				        """token-classification""": DistilBertForTokenClassification,
				        """zero-shot""": DistilBertForSequenceClassification,
				    }
				    if is_torch_available()
				    else {}
				)
				lowerCAmelCase__					    =    True
				lowerCAmelCase__					    =    True
				lowerCAmelCase__					    =    True
				lowerCAmelCase__					    =    True

				def 				__lowerCamelCase     (							self  :  Dict):







											'''simple docstring'''

											__lowercase       	=DistilBertModelTester(self)
											__lowercase       	=ConfigTester(self  ,       config_class=_lowerCAmelCase  ,       dim=3_7)

				def 				__lowerCamelCase     (							self  :  List[str]):







											'''simple docstring'''

											self.config_tester.run_common_tests()

				def 				__lowerCamelCase     (							self  :  List[Any]):







											'''simple docstring'''

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

				def 				__lowerCamelCase     (							self  :  Optional[int]):







											'''simple docstring'''

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

				def 				__lowerCamelCase     (							self  :  Optional[Any]):







											'''simple docstring'''

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

				def 				__lowerCamelCase     (							self  :  Any):







											'''simple docstring'''

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

				def 				__lowerCamelCase     (							self  :  List[str]):







											'''simple docstring'''

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

				def 				__lowerCamelCase     (							self  :  Tuple):







											'''simple docstring'''

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

				@slow
				def 				__lowerCamelCase     (							self  :  str):







											'''simple docstring'''

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

				@slow
				@require_torch_gpu
				def 				__lowerCamelCase     (							self  :  int):







											'''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=_lowerCAmelCase)

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

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





@require_torch
class _UpperCamelCase		(     unittest.TestCase		):





				'''simple docstring'''





				@slow
				def 				__lowerCamelCase     (							self  :  Dict):







											'''simple docstring'''

											__lowercase       	=DistilBertModel.from_pretrained('distilbert-base-uncased')
											__lowercase       	=torch.tensor([[0, 3_4_5, 2_3_2, 3_2_8, 7_4_0, 1_4_0, 1_6_9_5, 6_9, 6_0_7_8, 1_5_8_8, 2]])
											__lowercase       	=torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])
											with torch.no_grad():
																		__lowercase       	=model(_lowerCAmelCase  ,       attention_mask=_lowerCAmelCase)[0]
											__lowercase       	=torch.Size((1, 1_1, 7_6_8))
											self.assertEqual(output.shape  ,       _lowerCAmelCase)
											__lowercase       	=torch.tensor(
											    [[[-0.1639, 0.3299, 0.1648], [-0.1746, 0.3289, 0.1710], [-0.1884, 0.3357, 0.1810]]])

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








'''simple docstring'''



import warnings

from ...utils import logging
from .image_processing_deit import DeiTImageProcessor


lowerCamelCase	 =       logging.get_logger(__name__)





class _UpperCamelCase		(     A		):





				'''simple docstring'''





				def __init__(							self  :  Optional[int]  ,       *_lowerCAmelCase  :  Union[str, Any]  ,       **_lowerCAmelCase  :  Union[str, Any]):







											'''simple docstring'''

											warnings.warn(
											    'The class DeiTFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please'
											    ' use DeiTImageProcessor instead.'  ,       _lowerCAmelCase  ,       )
											super().__init__(*_lowerCAmelCase  ,       **_lowerCAmelCase)



