

'''simple docstring'''







import inspect
import unittest
from typing import List

import numpy as np

from transformers import EfficientFormerConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
      import tensorflow as tf

      from transformers import (
          TFEfficientFormerForImageClassification,
          TFEfficientFormerForImageClassificationWithTeacher,
          TFEfficientFormerModel,
      )
      from transformers.models.efficientformer.modeling_tf_efficientformer import (
          TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
      )


if is_vision_available():
      from PIL import Image

      from transformers import EfficientFormerImageProcessor


class        A__   :



    def __init__(       self		,					UpperCamelCase__		,					UpperCamelCase__ = 13		,					UpperCamelCase__ = 64		,					UpperCamelCase__ = 2		,					UpperCamelCase__ = 3		,					UpperCamelCase__ = 3		,					UpperCamelCase__ = True		,					UpperCamelCase__ = True		,					UpperCamelCase__ = 128		,					UpperCamelCase__=[16, 32, 64, 128]		,					UpperCamelCase__ = 7		,					UpperCamelCase__ = 4		,					UpperCamelCase__ = 37		,					UpperCamelCase__ = "gelu"		,					UpperCamelCase__ = 0.1		,					UpperCamelCase__ = 0.1		,					UpperCamelCase__ = 10		,					UpperCamelCase__ = 0.02		,					UpperCamelCase__ = 2		,					UpperCamelCase__ = 1		,					UpperCamelCase__ = 128		,					UpperCamelCase__ = [2, 2, 2, 2]		,					UpperCamelCase__ = 2		,					UpperCamelCase__ = 2		,					)    ->   Any:





           '''simple docstring'''
           A_						       =   parent
           A_						       =   batch_size
           A_						       =   image_size
           A_						       =   patch_size
           A_						       =   num_channels
           A_						       =   is_training
           A_						       =   use_labels
           A_						       =   hidden_size
           A_						       =   num_hidden_layers
           A_						       =   num_attention_heads
           A_						       =   intermediate_size
           A_						       =   hidden_act
           A_						       =   hidden_dropout_prob
           A_						       =   attention_probs_dropout_prob
           A_						       =   type_sequence_label_size
           A_						       =   initializer_range
           A_						       =   encoder_stride
           A_						       =   num_attention_outputs
           A_						       =   embed_dim
           A_						       =   embed_dim + 1
           A_						       =   resolution
           A_						       =   depths
           A_						       =   hidden_sizes
           A_						       =   dim
           A_						       =   mlp_expansion_ratio



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





           '''simple docstring'''
           A_						       =   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

           A_						       =   None
           if self.use_labels:
                  A_						       =   ids_tensor([self.batch_size]		,					self.type_sequence_label_size							)

           A_						       =   self.get_config()

           return config, pixel_values, labels



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





           '''simple docstring'''
           return EfficientFormerConfig(
               image_size=self.image_size		,					patch_size=self.patch_size		,					num_channels=self.num_channels		,					hidden_size=self.hidden_size		,					num_hidden_layers=self.num_hidden_layers		,					num_attention_heads=self.num_attention_heads		,					intermediate_size=self.intermediate_size		,					hidden_act=self.hidden_act		,					hidden_dropout_prob=self.hidden_dropout_prob		,					attention_probs_dropout_prob=self.attention_probs_dropout_prob		,					is_decoder=UpperCamelCase__		,					initializer_range=self.initializer_range		,					encoder_stride=self.encoder_stride		,					resolution=self.resolution		,					depths=self.depths		,					hidden_sizes=self.hidden_sizes		,					dim=self.dim		,					mlp_expansion_ratio=self.mlp_expansion_ratio		,					)



    def        snake_case_      (       self		,					UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__							)    ->   int:





           '''simple docstring'''
           A_						       =   TFEfficientFormerModel(config=UpperCamelCase__							)
           A_						       =   model(UpperCamelCase__		,					training=UpperCamelCase__							)
           self.parent.assertEqual(result.last_hidden_state.shape		,					(self.batch_size, self.seq_length, self.hidden_size)							)



    def        snake_case_      (       self		,					UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__							)    ->   Dict:





           '''simple docstring'''
           A_						       =   self.type_sequence_label_size
           A_						       =   TFEfficientFormerForImageClassification(UpperCamelCase__							)
           A_						       =   model(UpperCamelCase__		,					labels=UpperCamelCase__		,					training=UpperCamelCase__							)
           self.parent.assertEqual(result.logits.shape		,					(self.batch_size, self.type_sequence_label_size)							)

           # test greyscale images
           A_						       =   1
           A_						       =   TFEfficientFormerForImageClassification(UpperCamelCase__							)

           A_						       =   floats_tensor([self.batch_size, 1, self.image_size, self.image_size]							)
           A_						       =   model(UpperCamelCase__		,					labels=UpperCamelCase__							)
           self.parent.assertEqual(result.logits.shape		,					(self.batch_size, self.type_sequence_label_size)							)







    def        snake_case_      (       self							)    ->   Dict:





           '''simple docstring'''
           A_						       =   self.prepare_config_and_inputs()
           A_       ,      A_       ,      A_						       =   config_and_inputs
           A_						       =   {"""pixel_values""": pixel_values}
           return config, inputs_dict


@require_tf
class        A__   (   _snake_case    ,    _snake_case    ,    unittest.TestCase      ):
    lowercase						       =		(
        (
            TFEfficientFormerModel,
            TFEfficientFormerForImageClassificationWithTeacher,
            TFEfficientFormerForImageClassification,
        )
        if is_tf_available()
        else ()
    )
    lowercase						       =		(
        {
            "feature-extraction": TFEfficientFormerModel,
            "image-classification": (
                TFEfficientFormerForImageClassification,
                TFEfficientFormerForImageClassificationWithTeacher,
            ),
        }
        if is_tf_available()
        else {}
    )

    lowercase						       =		False

    lowercase						       =		False
    lowercase						       =		False
    lowercase						       =		False
    lowercase						       =		False



    def        snake_case_      (       self							)    ->   Dict:





           '''simple docstring'''
           A_						       =   TFEfficientFormerModelTester(self							)
           A_						       =   ConfigTester(
               self		,					config_class=UpperCamelCase__		,					has_text_modality=UpperCamelCase__		,					hidden_size=37							)



    def        snake_case_      (       self							)    ->   Any:





           '''simple docstring'''
           self.config_tester.run_common_tests()



    @unittest.skip(reason="""EfficientFormer does not use inputs_embeds"""							)
    def        snake_case_      (       self							)    ->   str:





           '''simple docstring'''
           pass



    @unittest.skip(reason="""EfficientFormer does not support input and output embeddings"""							)
    def        snake_case_      (       self							)    ->   Dict:





           '''simple docstring'''
           pass



    def        snake_case_      (       self							)    ->   str:





           '''simple docstring'''
           A_       ,      A_						       =   self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
                  A_						       =   model_class(UpperCamelCase__							)
                  A_						       =   inspect.signature(model.call							)
                  # signature.parameters is an OrderedDict => so arg_names order is deterministic
                  A_						       =   [*signature.parameters.keys()]

                  A_						       =   ["""pixel_values"""]
                  self.assertListEqual(arg_names[:1]		,					UpperCamelCase__							)



    def        snake_case_      (       self							)    ->   List[str]:





           '''simple docstring'''
           def check_hidden_states_output(UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__							):
                  A_						       =   model_class(UpperCamelCase__							)

                  A_						       =   model(**self._prepare_for_class(UpperCamelCase__		,					UpperCamelCase__							)		,					training=UpperCamelCase__							)
                  A_						       =   outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

                  A_						       =   getattr(
                      self.model_tester		,					"""expected_num_hidden_layers"""		,					self.model_tester.num_hidden_layers + 1							)
                  self.assertEqual(len(UpperCamelCase__							)		,					UpperCamelCase__							)

                  if hasattr(self.model_tester		,					"""encoder_seq_length"""							):
                         A_						       =   self.model_tester.encoder_seq_length
                         if hasattr(self.model_tester		,					"""chunk_length"""							) and self.model_tester.chunk_length > 1:
                                A_						       =   seq_length * self.model_tester.chunk_length
                  else:
                         A_						       =   self.model_tester.seq_length

                  self.assertListEqual(
                      list(hidden_states[-1].shape[-2:]							)		,					[seq_length, self.model_tester.hidden_size]		,					)

                  if config.is_encoder_decoder:
                         A_						       =   outputs.decoder_hidden_states

                         self.asseretIsInstance(UpperCamelCase__		,					(list, tuple)							)
                         self.assertEqual(len(UpperCamelCase__							)		,					UpperCamelCase__							)
                         A_						       =   getattr(self.model_tester		,					"""seq_length"""		,					UpperCamelCase__							)
                         A_						       =   getattr(self.model_tester		,					"""decoder_seq_length"""		,					UpperCamelCase__							)

                         self.assertListEqual(
                             list(hidden_states[-1].shape[-2:]							)		,					[decoder_seq_length, self.model_tester.hidden_size]		,					)

           A_       ,      A_						       =   self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
                  A_						       =   True
                  check_hidden_states_output(UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__							)

                  # check that output_hidden_states also work using config
                  del inputs_dict["output_hidden_states"]
                  A_						       =   True

                  check_hidden_states_output(UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__							)



    def        snake_case_      (       self		,					UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__=False							)    ->   Optional[int]:





           '''simple docstring'''
           A_						       =   super()._prepare_for_class(UpperCamelCase__		,					UpperCamelCase__		,					return_labels=UpperCamelCase__							)

           if return_labels:
                  if model_class.__name__ == "TFEfficientFormerForImageClassificationWithTeacher":
                         del inputs_dict["labels"]

           return inputs_dict



    def        snake_case_      (       self							)    ->   Tuple:





           '''simple docstring'''
           A_						       =   self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*UpperCamelCase__							)



    @unittest.skip(reason="""EfficientFormer does not implement masked image modeling yet"""							)
    def        snake_case_      (       self							)    ->   Optional[int]:





           '''simple docstring'''
           A_						       =   self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_masked_image_modeling(*UpperCamelCase__							)



    def        snake_case_      (       self							)    ->   List[str]:





           '''simple docstring'''
           A_						       =   self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_image_classification(*UpperCamelCase__							)



    @slow
    def        snake_case_      (       self							)    ->   Optional[int]:





           '''simple docstring'''
           for model_name in TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                  A_						       =   TFEfficientFormerModel.from_pretrained(UpperCamelCase__							)
                  self.assertIsNotNone(UpperCamelCase__							)



    def        snake_case_      (       self							)    ->   Tuple:





           '''simple docstring'''
           A_       ,      A_						       =   self.model_tester.prepare_config_and_inputs_for_common()
           A_						       =   True

           A_						       =   getattr(self.model_tester		,					"""seq_length"""		,					UpperCamelCase__							)
           A_						       =   getattr(self.model_tester		,					"""encoder_seq_length"""		,					UpperCamelCase__							)
           A_						       =   getattr(self.model_tester		,					"""key_length"""		,					UpperCamelCase__							)
           A_						       =   getattr(self.model_tester		,					"""chunk_length"""		,					UpperCamelCase__							)

           if chunk_length is not None and hasattr(self.model_tester		,					"""num_hashes"""							):
                  A_						       =   encoder_seq_length * self.model_tester.num_hashes

           for model_class in self.all_model_classes:
                  A_						       =   True
                  A_						       =   False
                  A_						       =   True
                  A_						       =   model_class(UpperCamelCase__							)

                  A_						       =   model(**self._prepare_for_class(UpperCamelCase__		,					UpperCamelCase__							)		,					training=UpperCamelCase__							)
                  A_						       =   outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
                  self.assertEqual(len(UpperCamelCase__							)		,					self.model_tester.num_attention_outputs							)

                  # check that output_attentions also work using config
                  del inputs_dict["output_attentions"]
                  A_						       =   True
                  A_						       =   model_class(UpperCamelCase__							)
                  A_						       =   model(**self._prepare_for_class(UpperCamelCase__		,					UpperCamelCase__							)		,					training=UpperCamelCase__							)

                  A_						       =   outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
                  self.assertEqual(len(UpperCamelCase__							)		,					self.model_tester.num_attention_outputs							)

                  if chunk_length is not None:
                         self.assertListEqual(
                             list(attentions[0].shape[-4:]							)		,					[self.model_tester.num_attention_heads, encoder_seq_length, chunk_length, encoder_key_length]		,					)
                  else:
                         self.assertListEqual(
                             list(attentions[0].shape[-3:]							)		,					[self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]		,					)







    def        snake_case_      (       self							)    ->   List[Any]:





           '''simple docstring'''
           # We use a simplified version of this test for EfficientFormer because it requires training=False
           # and Keras refuses to let us force that during functional construction
           A_       ,      A_						       =   self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
                  # Prepare our model
                  A_						       =   model_class(UpperCamelCase__							)
                  # These are maximally general inputs for the model, with multiple None dimensions
                  # Hopefully this will catch any conditionals that fail for flexible shapes
                  A_						       =   {
                      key: tf.keras.Input(shape=val.shape[1:]		,					dtype=val.dtype		,					name=UpperCamelCase__							)
                      for key, val in model.input_signature.items()
                      if key in model.dummy_inputs
                  }
                  A_						       =   model(UpperCamelCase__							)
                  self.assertTrue(outputs_dict is not None							)

def    UpperCAmelCase__     (   )      ->      Dict:
       A_						       =   Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""					)
       return image







@require_tf
@require_vision
class        A__   (   unittest.TestCase      ):



    @cached_property
    def        snake_case_      (       self							)    ->   List[Any]:





           '''simple docstring'''
           return (
               EfficientFormerImageProcessor.from_pretrained("""snap-research/efficientformer-l1-300"""							)
               if is_vision_available()
               else None
           )



    @slow
    def        snake_case_      (       self							)    ->   Optional[int]:





           '''simple docstring'''
           A_						       =   TFEfficientFormerForImageClassification.from_pretrained("""snap-research/efficientformer-l1-300"""							)
           A_						       =   self.default_image_processor
           A_						       =   prepare_img()
           A_						       =   image_processor(images=UpperCamelCase__		,					return_tensors="""tf"""							)
           # forward pass
           A_						       =   model(**UpperCamelCase__		,					training=UpperCamelCase__							)
           # verify the logits
           A_						       =   tf.TensorShape((1, 1000)							)
           self.assertEqual(outputs.logits.shape		,					UpperCamelCase__							)
           A_						       =   tf.constant([-0.0555, 0.4825, -0.0852]							)
           self.assertTrue(np.allclose(outputs.logits[0, :3]		,					UpperCamelCase__		,					atol=1e-4							)							)







    @slow
    def        snake_case_      (       self							)    ->   List[str]:





           '''simple docstring'''
           A_						       =   TFEfficientFormerForImageClassificationWithTeacher.from_pretrained(
               """snap-research/efficientformer-l1-300"""							)
           A_						       =   self.default_image_processor
           A_						       =   prepare_img()
           A_						       =   image_processor(images=UpperCamelCase__		,					return_tensors="""tf"""							)
           # forward pass
           A_						       =   model(**UpperCamelCase__		,					training=UpperCamelCase__							)
           # verify the logits
           A_						       =   tf.TensorShape((1, 1000)							)
           self.assertEqual(outputs.logits.shape		,					UpperCamelCase__							)
           A_						       =   tf.constant([-0.1312, 0.4353, -1.0499]							)
           self.assertTrue(np.allclose(outputs.logits[0, :3]		,					UpperCamelCase__		,					atol=1e-4							)							)



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



    def __init__(       self		,					UpperCamelCase__		,					UpperCamelCase__=13		,					UpperCamelCase__=7		,					UpperCamelCase__=True		,					UpperCamelCase__=True		,					UpperCamelCase__=False		,					UpperCamelCase__=True		,					UpperCamelCase__=99		,					UpperCamelCase__=32		,					UpperCamelCase__=5		,					UpperCamelCase__=4		,					UpperCamelCase__=37		,					UpperCamelCase__="gelu"		,					UpperCamelCase__=0.1		,					UpperCamelCase__=0.1		,					UpperCamelCase__=512		,					UpperCamelCase__=16		,					UpperCamelCase__=2		,					UpperCamelCase__=0.02		,					UpperCamelCase__=3		,					UpperCamelCase__=4		,					UpperCamelCase__=None		,					)    ->   Dict:





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



    def        snake_case_      (       self							)    ->   List[Any]:





           '''simple docstring'''
           A_						       =   ids_tensor([self.batch_size, self.seq_length]		,					self.vocab_size							)

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

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

           A_						       =   self.get_config()

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



    def        snake_case_      (       self							)    ->   List[str]:





           '''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        snake_case_      (       self		,					UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__							)    ->   Union[str, Any]:





           '''simple docstring'''
           A_						       =   DistilBertModel(config=UpperCamelCase__							)
           model.to(UpperCamelCase__							)
           model.eval()
           A_						       =   model(UpperCamelCase__		,					UpperCamelCase__							)
           A_						       =   model(UpperCamelCase__							)
           self.parent.assertEqual(result.last_hidden_state.shape		,					(self.batch_size, self.seq_length, self.hidden_size)							)



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





           '''simple docstring'''
           A_						       =   DistilBertForMaskedLM(config=UpperCamelCase__							)
           model.to(UpperCamelCase__							)
           model.eval()
           A_						       =   model(UpperCamelCase__		,					attention_mask=UpperCamelCase__		,					labels=UpperCamelCase__							)
           self.parent.assertEqual(result.logits.shape		,					(self.batch_size, self.seq_length, self.vocab_size)							)



    def        snake_case_      (       self		,					UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__							)    ->   Dict:





           '''simple docstring'''
           A_						       =   DistilBertForQuestionAnswering(config=UpperCamelCase__							)
           model.to(UpperCamelCase__							)
           model.eval()
           A_						       =   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        snake_case_      (       self		,					UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__							)    ->   Union[str, Any]:





           '''simple docstring'''
           A_						       =   self.num_labels
           A_						       =   DistilBertForSequenceClassification(UpperCamelCase__							)
           model.to(UpperCamelCase__							)
           model.eval()
           A_						       =   model(UpperCamelCase__		,					attention_mask=UpperCamelCase__		,					labels=UpperCamelCase__							)
           self.parent.assertEqual(result.logits.shape		,					(self.batch_size, self.num_labels)							)



    def        snake_case_      (       self		,					UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__							)    ->   Any:





           '''simple docstring'''
           A_						       =   self.num_labels
           A_						       =   DistilBertForTokenClassification(config=UpperCamelCase__							)
           model.to(UpperCamelCase__							)
           model.eval()

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



    def        snake_case_      (       self		,					UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__							)    ->   List[Any]:





           '''simple docstring'''
           A_						       =   self.num_choices
           A_						       =   DistilBertForMultipleChoice(config=UpperCamelCase__							)
           model.to(UpperCamelCase__							)
           model.eval()
           A_						       =   input_ids.unsqueeze(1							).expand(-1		,					self.num_choices		,					-1							).contiguous()
           A_						       =   input_mask.unsqueeze(1							).expand(-1		,					self.num_choices		,					-1							).contiguous()
           A_						       =   model(
               UpperCamelCase__		,					attention_mask=UpperCamelCase__		,					labels=UpperCamelCase__		,					)
           self.parent.assertEqual(result.logits.shape		,					(self.batch_size, self.num_choices)							)







    def        snake_case_      (       self							)    ->   Tuple:





           '''simple docstring'''
           A_						       =   self.prepare_config_and_inputs()
           ((A_)       ,      (A_)       ,      (A_)       ,      (A_)       ,      (A_)       ,      (A_))						       =   config_and_inputs
           A_						       =   {"""input_ids""": input_ids, """attention_mask""": input_mask}
           return config, inputs_dict


@require_torch
class        A__   (   _snake_case    ,    _snake_case    ,    unittest.TestCase      ):
    lowercase						       =		(
        (
            DistilBertModel,
            DistilBertForMaskedLM,
            DistilBertForMultipleChoice,
            DistilBertForQuestionAnswering,
            DistilBertForSequenceClassification,
            DistilBertForTokenClassification,
        )
        if is_torch_available()
        else None
    )
    lowercase						       =		(
        {
            "feature-extraction": DistilBertModel,
            "fill-mask": DistilBertForMaskedLM,
            "question-answering": DistilBertForQuestionAnswering,
            "text-classification": DistilBertForSequenceClassification,
            "token-classification": DistilBertForTokenClassification,
            "zero-shot": DistilBertForSequenceClassification,
        }
        if is_torch_available()
        else {}
    )
    lowercase						       =		True
    lowercase						       =		True
    lowercase						       =		True
    lowercase						       =		True



    def        snake_case_      (       self							)    ->   Tuple:





           '''simple docstring'''
           A_						       =   DistilBertModelTester(self							)
           A_						       =   ConfigTester(self		,					config_class=UpperCamelCase__		,					dim=37							)



    def        snake_case_      (       self							)    ->   List[Any]:





           '''simple docstring'''
           self.config_tester.run_common_tests()



    def        snake_case_      (       self							)    ->   Tuple:





           '''simple docstring'''
           A_						       =   self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_distilbert_model(*UpperCamelCase__							)



    def        snake_case_      (       self							)    ->   List[Any]:





           '''simple docstring'''
           A_						       =   self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_distilbert_for_masked_lm(*UpperCamelCase__							)



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





           '''simple docstring'''
           A_						       =   self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_distilbert_for_question_answering(*UpperCamelCase__							)



    def        snake_case_      (       self							)    ->   Any:





           '''simple docstring'''
           A_						       =   self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_distilbert_for_sequence_classification(*UpperCamelCase__							)



    def        snake_case_      (       self							)    ->   Dict:





           '''simple docstring'''
           A_						       =   self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_distilbert_for_token_classification(*UpperCamelCase__							)



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





           '''simple docstring'''
           A_						       =   self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_distilbert_for_multiple_choice(*UpperCamelCase__							)



    @slow
    def        snake_case_      (       self							)    ->   Tuple:





           '''simple docstring'''
           for model_name in DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                  A_						       =   DistilBertModel.from_pretrained(UpperCamelCase__							)
                  self.assertIsNotNone(UpperCamelCase__							)







    @slow
    @require_torch_gpu
    def        snake_case_      (       self							)    ->   str:





           '''simple docstring'''
           A_       ,      A_						       =   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

                  A_						       =   True
                  A_						       =   model_class(config=UpperCamelCase__							)

                  A_						       =   self._prepare_for_class(UpperCamelCase__		,					UpperCamelCase__							)
                  A_						       =   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"""							)							)
                         A_						       =   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      ):



    @slow
    def        snake_case_      (       self							)    ->   int:





           '''simple docstring'''
           A_						       =   DistilBertModel.from_pretrained("""distilbert-base-uncased"""							)
           A_						       =   torch.tensor([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]]							)
           A_						       =   torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]							)
           with torch.no_grad():
                  A_						       =   model(UpperCamelCase__		,					attention_mask=UpperCamelCase__							)[0]
           A_						       =   torch.Size((1, 11, 768)							)
           self.assertEqual(output.shape		,					UpperCamelCase__							)
           A_						       =   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]		,					UpperCamelCase__		,					atol=1e-4							)							)
