






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     (  _lowerCAmelCase ):







	def __init__(	self   :				int							,					_lowerCAmelCase   :				str							,					_lowerCAmelCase   :				List[str]=13							,					_lowerCAmelCase   :				List[str]=7							,					_lowerCAmelCase   :				List[str]=True							,					_lowerCAmelCase   :				Dict=True							,					_lowerCAmelCase   :				Union[str, Any]=False							,					_lowerCAmelCase   :				List[str]=True							,					_lowerCAmelCase   :				int=99							,					_lowerCAmelCase   :				Any=32							,					_lowerCAmelCase   :				Optional[int]=5							,					_lowerCAmelCase   :				Any=4							,					_lowerCAmelCase   :				Tuple=37							,					_lowerCAmelCase   :				str="gelu"							,					_lowerCAmelCase   :				List[str]=0.1							,					_lowerCAmelCase   :				Tuple=0.1							,					_lowerCAmelCase   :				Union[str, Any]=512							,					_lowerCAmelCase   :				Dict=16							,					_lowerCAmelCase   :				List[Any]=2							,					_lowerCAmelCase   :				Optional[int]=0.02							,					_lowerCAmelCase   :				int=3							,					_lowerCAmelCase   :				Dict=4							,					_lowerCAmelCase   :				List[Any]=None							,					)		->			List[Any]:
		"""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 			_a (	self   :				List[str]      )		->			Optional[int]:
		"""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 			_a (	self   :				Optional[Any]      )		->			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 			_a (	self   :				List[Any]							,					_lowerCAmelCase   :				Any							,					_lowerCAmelCase   :				Union[str, Any]							,					_lowerCAmelCase   :				Optional[int]							,					_lowerCAmelCase   :				Optional[int]							,					_lowerCAmelCase   :				Any							,					_lowerCAmelCase   :				Any      )		->			Dict:
		"""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 			_a (	self   :				List[Any]							,					_lowerCAmelCase   :				Optional[Any]							,					_lowerCAmelCase   :				List[Any]							,					_lowerCAmelCase   :				List[str]							,					_lowerCAmelCase   :				Optional[Any]							,					_lowerCAmelCase   :				str							,					_lowerCAmelCase   :				Any      )		->			List[str]:
		"""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 			_a (	self   :				str							,					_lowerCAmelCase   :				List[Any]							,					_lowerCAmelCase   :				Union[str, Any]							,					_lowerCAmelCase   :				Optional[int]							,					_lowerCAmelCase   :				int							,					_lowerCAmelCase   :				Optional[Any]							,					_lowerCAmelCase   :				Optional[int]      )		->			Union[str, 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 			_a (	self   :				List[Any]							,					_lowerCAmelCase   :				Union[str, Any]							,					_lowerCAmelCase   :				Tuple							,					_lowerCAmelCase   :				Union[str, Any]							,					_lowerCAmelCase   :				Tuple							,					_lowerCAmelCase   :				Union[str, Any]							,					_lowerCAmelCase   :				Optional[int]      )		->			int:
		"""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 			_a (	self   :				Union[str, Any]							,					_lowerCAmelCase   :				Optional[int]							,					_lowerCAmelCase   :				List[str]							,					_lowerCAmelCase   :				Optional[int]							,					_lowerCAmelCase   :				Any							,					_lowerCAmelCase   :				List[Any]							,					_lowerCAmelCase   :				Optional[int]      )		->			Optional[Any]:
		"""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 			_a (	self   :				Tuple							,					_lowerCAmelCase   :				str							,					_lowerCAmelCase   :				Optional[int]							,					_lowerCAmelCase   :				Union[str, Any]							,					_lowerCAmelCase   :				Any							,					_lowerCAmelCase   :				Optional[Any]							,					_lowerCAmelCase   :				List[Any]      )		->			str:
		"""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 			_a (	self   :				List[Any]      )		->			Optional[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     (  _lowerCAmelCase ,      _lowerCAmelCase ,      unittest.TestCase ):
	__snake_case						:Optional[Any] =							(
	    (
	        DistilBertModel,
	        DistilBertForMaskedLM,
	        DistilBertForMultipleChoice,
	        DistilBertForQuestionAnswering,
	        DistilBertForSequenceClassification,
	        DistilBertForTokenClassification,
	    )
	    if is_torch_available()
	    else None
	)
	__snake_case						:Dict =							(
	    {
	        'feature-extraction': DistilBertModel,
	        'fill-mask': DistilBertForMaskedLM,
	        'question-answering': DistilBertForQuestionAnswering,
	        'text-classification': DistilBertForSequenceClassification,
	        'token-classification': DistilBertForTokenClassification,
	        'zero-shot': DistilBertForSequenceClassification,
	    }
	    if is_torch_available()
	    else {}
	)
	__snake_case						:Tuple =							True
	__snake_case						:Tuple =							True
	__snake_case						:List[str] =							True
	__snake_case						:Optional[int] =							True







	def 			_a (	self   :				Optional[Any]      )		->			List[Any]:
		"""simple docstring"""







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







	def 			_a (	self   :				Dict      )		->			str:
		"""simple docstring"""







		self.config_tester.run_common_tests()







	def 			_a (	self   :				Optional[Any]      )		->			int:
		"""simple docstring"""







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







	def 			_a (	self   :				Tuple      )		->			Union[str, Any]:
		"""simple docstring"""







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







	def 			_a (	self   :				Optional[Any]      )		->			Dict:
		"""simple docstring"""







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







	def 			_a (	self   :				str      )		->			Optional[Any]:
		"""simple docstring"""







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







	def 			_a (	self   :				Any      )		->			Union[str, Any]:
		"""simple docstring"""







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







	def 			_a (	self   :				List[str]      )		->			List[Any]:
		"""simple docstring"""







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







	@slow
	def 			_a (	self   :				int      )		->			Optional[Any]:
		"""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 			_a (	self   :				Union[str, Any]      )		->			Optional[Any]:
		"""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 ):







	@slow
	def 			_a (	self   :				List[Any]      )		->			Union[str, Any]:
		"""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(_lowerCAmelCase							,					attention_mask=_lowerCAmelCase      )[0]
		__lowercase   							=	torch.Size((1, 11, 768)      )
		self.assertEqual(output.shape							,					_lowerCAmelCase      )
		__lowercase   							=	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]							,					_lowerCAmelCase							,					atol=1e-4      )      )





'''simple docstring'''



from __future__ import annotations

A__						:   int				=    10



def      UpperCAmelCase__   (      UpperCAmelCase_       :							list[int]				)	->						list[int]:
     __lowerCamelCase  :      List[Any]														=						1
     __lowerCamelCase  :      Any														=						max(UpperCAmelCase_				)
     while placement <= max_digit:
          # declare and initialize empty buckets
          __lowerCamelCase  :      list[list]														=						[[] for _ in range(UpperCAmelCase_				)]
          # split list_of_ints between the buckets
          for i in list_of_ints:
               __lowerCamelCase  :      List[Any]														=						int((i / placement) % RADIX				)
               buckets[tmp].append(UpperCAmelCase_				)
          # put each buckets' contents into list_of_ints
          __lowerCamelCase  :      Tuple														=						0
          for b in range(UpperCAmelCase_				):
               for i in buckets[b]:
                    __lowerCamelCase  :      List[Any]														=						i
                    a += 1
        # move to next
          placement *= RADIX
     return list_of_ints


if __name__ == "__main__":
      import doctest

      doctest.testmod()






