


'''simple docstring'''
import json
import os
from functools import lru_cache
from typing import List, Optional, Tuple

import regex as re

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


UpperCamelCase__    					=      logging.get_logger(__name__)


UpperCamelCase__    					=      {'''vocab_file''': '''vocab.json''', '''merges_file''': '''merges.txt'''}

# See all BART models at https://huggingface.co/models?filter=bart
UpperCamelCase__    					=      {
    '''vocab_file''': {
        '''facebook/bart-base''': '''https://huggingface.co/facebook/bart-base/resolve/main/vocab.json''',
        '''facebook/bart-large''': '''https://huggingface.co/facebook/bart-large/resolve/main/vocab.json''',
        '''facebook/bart-large-mnli''': '''https://huggingface.co/facebook/bart-large-mnli/resolve/main/vocab.json''',
        '''facebook/bart-large-cnn''': '''https://huggingface.co/facebook/bart-large-cnn/resolve/main/vocab.json''',
        '''facebook/bart-large-xsum''': '''https://huggingface.co/facebook/bart-large-xsum/resolve/main/vocab.json''',
        '''yjernite/bart_eli5''': '''https://huggingface.co/yjernite/bart_eli5/resolve/main/vocab.json''',
    },
    '''merges_file''': {
        '''facebook/bart-base''': '''https://huggingface.co/facebook/bart-base/resolve/main/merges.txt''',
        '''facebook/bart-large''': '''https://huggingface.co/facebook/bart-large/resolve/main/merges.txt''',
        '''facebook/bart-large-mnli''': '''https://huggingface.co/facebook/bart-large-mnli/resolve/main/merges.txt''',
        '''facebook/bart-large-cnn''': '''https://huggingface.co/facebook/bart-large-cnn/resolve/main/merges.txt''',
        '''facebook/bart-large-xsum''': '''https://huggingface.co/facebook/bart-large-xsum/resolve/main/merges.txt''',
        '''yjernite/bart_eli5''': '''https://huggingface.co/yjernite/bart_eli5/resolve/main/merges.txt''',
    },
}

UpperCamelCase__    					=      {
    '''facebook/bart-base''': 1_0_2_4,
    '''facebook/bart-large''': 1_0_2_4,
    '''facebook/bart-large-mnli''': 1_0_2_4,
    '''facebook/bart-large-cnn''': 1_0_2_4,
    '''facebook/bart-large-xsum''': 1_0_2_4,
    '''yjernite/bart_eli5''': 1_0_2_4,
}





@lru_cache()
def 					a__       (					)    ->	Dict:
    UpperCAmelCase__			:		Any													=				(
        list(range(ord('''!'''						)  ,					ord('''~'''						) + 1						)						) + list(range(ord('''¡'''						)  ,					ord('''¬'''						) + 1						)						) + list(range(ord('''®'''						)  ,					ord('''ÿ'''						) + 1						)						)
    )
    UpperCAmelCase__			:		Union[str, Any]													=				bs[:]
    UpperCAmelCase__			:		Dict													=				0
    for b in range(2**8						):
        if b not in bs:
            bs.append(lowercase__						)
            cs.append(2**8 + n						)
            n += 1
    UpperCAmelCase__			:		int													=				[chr(lowercase__						) for n in cs]
    return dict(zip(lowercase__  ,					lowercase__						)						)





def 					a__       (					lowerCAmelCase__						)    ->	Optional[Any]:
    UpperCAmelCase__			:		Any													=				set()
    UpperCAmelCase__			:		Any													=				word[0]
    for char in word[1:]:
        pairs.add((prev_char, char)						)
        UpperCAmelCase__			:		List[str]													=				char
    return pairs







class 			lowerCamelCase_   (	A_      ):
      lowerCAmelCase__		     =     VOCAB_FILES_NAMES
      lowerCAmelCase__		     =     PRETRAINED_VOCAB_FILES_MAP
      lowerCAmelCase__		     =     PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
      lowerCAmelCase__		     =     ['''input_ids''', '''attention_mask''']






      def __init__(					self				:    List[Any]						,						_A				:    Union[str, Any]						,						_A				:    List[Any]						,						_A				:    Union[str, Any]="replace"						,						_A				:    Dict="<s>"						,						_A				:    Tuple="</s>"						,						_A				:    Union[str, Any]="</s>"						,						_A				:    Any="<s>"						,						_A				:    Any="<unk>"						,						_A				:    Any="<pad>"						,						_A				:    int="<mask>"						,						_A				:    Tuple=False						,						**_A				:    str						,						):


          '''simple docstring'''


          UpperCAmelCase__			:		str													=				AddedToken(_A						,						lstrip=_A						,						rstrip=_A ) if isinstance(_A						,						_A ) else bos_token
          UpperCAmelCase__			:		str													=				AddedToken(_A						,						lstrip=_A						,						rstrip=_A ) if isinstance(_A						,						_A ) else eos_token
          UpperCAmelCase__			:		Any													=				AddedToken(_A						,						lstrip=_A						,						rstrip=_A ) if isinstance(_A						,						_A ) else sep_token
          UpperCAmelCase__			:		List[str]													=				AddedToken(_A						,						lstrip=_A						,						rstrip=_A ) if isinstance(_A						,						_A ) else cls_token
          UpperCAmelCase__			:		Any													=				AddedToken(_A						,						lstrip=_A						,						rstrip=_A ) if isinstance(_A						,						_A ) else unk_token
          UpperCAmelCase__			:		List[Any]													=				AddedToken(_A						,						lstrip=_A						,						rstrip=_A ) if isinstance(_A						,						_A ) else pad_token

          # Mask token behave like a normal word, i.e. include the space before it
          UpperCAmelCase__			:		int													=				AddedToken(_A						,						lstrip=_A						,						rstrip=_A ) if isinstance(_A						,						_A ) else mask_token

          super().__init__(
              errors=_A						,						bos_token=_A						,						eos_token=_A						,						unk_token=_A						,						sep_token=_A						,						cls_token=_A						,						pad_token=_A						,						mask_token=_A						,						add_prefix_space=_A						,						**_A						,						)

          with open(_A						,						encoding='''utf-8''' ) as vocab_handle:
              UpperCAmelCase__			:		int													=				json.load(_A )
          UpperCAmelCase__			:		Union[str, Any]													=				{v: k for k, v in self.encoder.items()}
          UpperCAmelCase__			:		Union[str, Any]													=				errors  # how to handle errors in decoding
          UpperCAmelCase__			:		Any													=				bytes_to_unicode()
          UpperCAmelCase__			:		Tuple													=				{v: k for k, v in self.byte_encoder.items()}
          with open(_A						,						encoding='''utf-8''' ) as merges_handle:
              UpperCAmelCase__			:		List[Any]													=				merges_handle.read().split('''\n''' )[1:-1]
          UpperCAmelCase__			:		Union[str, Any]													=				[tuple(merge.split() ) for merge in bpe_merges]
          UpperCAmelCase__			:		Optional[int]													=				dict(zip(_A						,						range(len(_A ) ) ) )
          UpperCAmelCase__			:		List[Any]													=				{}
          UpperCAmelCase__			:		Optional[int]													=				add_prefix_space

          # Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
          UpperCAmelCase__			:		int													=				re.compile(R'''\'s|\'t|\'re|\'ve|\'m|\'ll|\'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+''' )






      @property
      def lowercase_							(					self				:    Union[str, Any] ):


          '''simple docstring'''


          return len(self.encoder )






      def lowercase_							(					self				:    Dict ):


          '''simple docstring'''


          return dict(self.encoder						,						**self.added_tokens_encoder )






      def lowercase_							(					self				:    Dict						,						_A				:    Dict ):


          '''simple docstring'''


          if token in self.cache:
              return self.cache[token]
          UpperCAmelCase__			:		int													=				tuple(_A )
          UpperCAmelCase__			:		List[Any]													=				get_pairs(_A )

          if not pairs:
              return token

          while True:
              UpperCAmelCase__			:		Any													=				min(_A						,						key=lambda _A : self.bpe_ranks.get(_A						,						float('''inf''' ) ) )
              if bigram not in self.bpe_ranks:
                  break
              UpperCAmelCase__						,						UpperCAmelCase__			:		Optional[int]													=				bigram
              UpperCAmelCase__			:		Dict													=				[]
              UpperCAmelCase__			:		str													=				0
              while i < len(_A ):
                  try:
                      UpperCAmelCase__			:		Any													=				word.index(_A						,						_A )
                  except ValueError:
                      new_word.extend(word[i:] )
                      break
                  else:
                      new_word.extend(word[i:j] )
                      UpperCAmelCase__			:		List[Any]													=				j

                  if word[i] == first and i < len(_A ) - 1 and word[i + 1] == second:
                      new_word.append(first + second )
                      i += 2
                  else:
                      new_word.append(word[i] )
                      i += 1
              UpperCAmelCase__			:		Tuple													=				tuple(_A )
              UpperCAmelCase__			:		int													=				new_word
              if len(_A ) == 1:
                  break
              else:
                  UpperCAmelCase__			:		str													=				get_pairs(_A )
          UpperCAmelCase__			:		Optional[int]													=				''' '''.join(_A )
          UpperCAmelCase__			:		str													=				word
          return word






      def lowercase_							(					self				:    Optional[Any]						,						_A				:    Optional[int] ):


          '''simple docstring'''


          UpperCAmelCase__			:		str													=				[]
          for token in re.findall(self.pat						,						_A ):
              UpperCAmelCase__			:		Union[str, Any]													=				''''''.join(
                  self.byte_encoder[b] for b in token.encode('''utf-8''' ) )  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
              bpe_tokens.extend(bpe_token for bpe_token in self.bpe(_A ).split(''' ''' ) )
          return bpe_tokens






      def lowercase_							(					self				:    str						,						_A				:    Union[str, Any] ):


          '''simple docstring'''


          return self.encoder.get(_A						,						self.encoder.get(self.unk_token ) )






      def lowercase_							(					self				:    str						,						_A				:    str ):


          '''simple docstring'''


          return self.decoder.get(_A )






      def lowercase_							(					self				:    Union[str, Any]						,						_A				:    List[str] ):


          '''simple docstring'''


          UpperCAmelCase__			:		str													=				''''''.join(_A )
          UpperCAmelCase__			:		List[Any]													=				bytearray([self.byte_decoder[c] for c in text] ).decode('''utf-8'''						,						errors=self.errors )
          return text






      def lowercase_							(					self				:    str						,						_A				:    Optional[Any]						,						_A				:    str = None ):


          '''simple docstring'''


          if not os.path.isdir(_A ):
              logger.error(f"""Vocabulary path ({save_directory}) should be a directory""" )
              return
          UpperCAmelCase__			:		Dict													=				os.path.join(
              _A						,						(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file'''] )
          UpperCAmelCase__			:		Optional[Any]													=				os.path.join(
              _A						,						(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''merges_file'''] )

          with open(_A						,						'''w'''						,						encoding='''utf-8''' ) as f:
              f.write(json.dumps(self.encoder						,						indent=2						,						sort_keys=_A						,						ensure_ascii=_A ) + '''\n''' )

          UpperCAmelCase__			:		int													=				0
          with open(_A						,						'''w'''						,						encoding='''utf-8''' ) as writer:
              writer.write('''#version: 0.2\n''' )
              for bpe_tokens, token_index in sorted(self.bpe_ranks.items()						,						key=lambda _A : kv[1] ):
                  if index != token_index:
                      logger.warning(
                          f"""Saving vocabulary to {merge_file}: BPE merge indices are not consecutive."""
                          ''' Please check that the tokenizer is not corrupted!''' )
                      UpperCAmelCase__			:		Tuple													=				token_index
                  writer.write(''' '''.join(_A ) + '''\n''' )
                  index += 1

          return vocab_file, merge_file






      def lowercase_							(					self				:    Tuple						,						_A				:    int						,						_A				:    List[Any] = None ):


          '''simple docstring'''


          if token_ids_a is None:
              return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
          UpperCAmelCase__			:		List[Any]													=				[self.cls_token_id]
          UpperCAmelCase__			:		Optional[Any]													=				[self.sep_token_id]
          return cls + token_ids_a + sep + sep + token_ids_a + sep






      def lowercase_							(					self				:    List[str]						,						_A				:    Tuple						,						_A				:    int = None						,						_A				:    List[Any] = False ):


          '''simple docstring'''


          if already_has_special_tokens:
              return super().get_special_tokens_mask(
                  token_ids_a=_A						,						token_ids_a=_A						,						already_has_special_tokens=_A )

          if token_ids_a is None:
              return [1] + ([0] * len(_A )) + [1]
          return [1] + ([0] * len(_A )) + [1, 1] + ([0] * len(_A )) + [1]






      def lowercase_							(					self				:    int						,						_A				:    Dict						,						_A				:    Tuple = None ):


          '''simple docstring'''


          UpperCAmelCase__			:		Dict													=				[self.sep_token_id]
          UpperCAmelCase__			:		List[str]													=				[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 + sep + token_ids_a + sep ) * [0]






      def lowercase_							(					self				:    int						,						_A				:    Optional[int]						,						_A				:    Any=False						,						**_A				:    List[Any] ):


          '''simple docstring'''


          UpperCAmelCase__			:		int													=				kwargs.pop('''add_prefix_space'''						,						self.add_prefix_space )
          if (is_split_into_words or add_prefix_space) and (len(_A ) > 0 and not text[0].isspace()):
              UpperCAmelCase__			:		Any													=				''' ''' + text
          return (text, kwargs)




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


							def __init__(self      ,				lowerCAmelCase      ,				lowerCAmelCase=1_3      ,				lowerCAmelCase=7      ,				lowerCAmelCase=True      ,				lowerCAmelCase=True      ,				lowerCAmelCase=False      ,				lowerCAmelCase=True      ,				lowerCAmelCase=9_9      ,				lowerCAmelCase=3_2      ,				lowerCAmelCase=5      ,				lowerCAmelCase=4      ,				lowerCAmelCase=3_7      ,				lowerCAmelCase="gelu"      ,				lowerCAmelCase=0.1      ,				lowerCAmelCase=0.1      ,				lowerCAmelCase=5_1_2      ,				lowerCAmelCase=1_6      ,				lowerCAmelCase=2      ,				lowerCAmelCase=0.02      ,				lowerCAmelCase=3      ,				lowerCAmelCase=4      ,				lowerCAmelCase=None      ,				):
									__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					):
									__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					):
									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      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase					):
									__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      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase					):
									__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      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase					):
									__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      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase					):
									__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      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase					):
									__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      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase					):
									__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					):
									__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       A    (   A_					,				A_					,				unittest.TestCase ):
							UpperCamelCase_   :							Any       =(
							    (
							        DistilBertModel,
							        DistilBertForMaskedLM,
							        DistilBertForMultipleChoice,
							        DistilBertForQuestionAnswering,
							        DistilBertForSequenceClassification,
							        DistilBertForTokenClassification,
							    )
							    if is_torch_available()
							    else None
							)
							UpperCamelCase_   :							Optional[int]       =(
							    {
							        '''feature-extraction''': DistilBertModel,
							        '''fill-mask''': DistilBertForMaskedLM,
							        '''question-answering''': DistilBertForQuestionAnswering,
							        '''text-classification''': DistilBertForSequenceClassification,
							        '''token-classification''': DistilBertForTokenClassification,
							        '''zero-shot''': DistilBertForSequenceClassification,
							    }
							    if is_torch_available()
							    else {}
							)
							UpperCamelCase_   :							str       =True
							UpperCamelCase_   :							str       =True
							UpperCamelCase_   :							Union[str, Any]       =True
							UpperCamelCase_   :							Optional[int]       =True


							def 			_A       (self					):
									__lowercase=			DistilBertModelTester(self					)
									__lowercase=			ConfigTester(self      ,				config_class=lowerCAmelCase      ,				dim=3_7					)


							def 			_A       (self					):
									self.config_tester.run_common_tests()


							def 			_A       (self					):
									__lowercase=			self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_distilbert_model(*lowerCAmelCase					)


							def 			_A       (self					):
									__lowercase=			self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_distilbert_for_masked_lm(*lowerCAmelCase					)


							def 			_A       (self					):
									__lowercase=			self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_distilbert_for_question_answering(*lowerCAmelCase					)


							def 			_A       (self					):
									__lowercase=			self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_distilbert_for_sequence_classification(*lowerCAmelCase					)


							def 			_A       (self					):
									__lowercase=			self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_distilbert_for_token_classification(*lowerCAmelCase					)


							def 			_A       (self					):
									__lowercase=			self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_distilbert_for_multiple_choice(*lowerCAmelCase					)


							@slow
							def 			_A       (self					):
									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					):
									__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       A    (   unittest.TestCase ):


							@slow
							def 			_A       (self					):
									__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.16_39, 0.32_99, 0.16_48], [-0.17_46, 0.32_89, 0.17_10], [-0.18_84, 0.33_57, 0.18_10]]]					)

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






