code: 
  
  
  
  import inspect
  import unittest
  
  from transformers import EfficientNetConfig
  from transformers.testing_utils import is_pipeline_test, require_torch, require_vision, slow, torch_device
  from transformers.utils import cached_property, is_torch_available, is_vision_available
  
  from ...test_configuration_common import ConfigTester
  from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
  from ...test_pipeline_mixin import PipelineTesterMixin
  
  
  if is_torch_available():
      import torch
  
      from transformers import EfficientNetForImageClassification, EfficientNetModel
      from transformers.models.efficientnet.modeling_efficientnet import EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST
  
  
  if is_vision_available():
      from PIL import Image
  
      from transformers import AutoImageProcessor
  
  
  
  class        lowerCAmelCase_	:
         def __init__(    self,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_=13,    SCREAMING_SNAKE_CASE_=32,    SCREAMING_SNAKE_CASE_=3,    SCREAMING_SNAKE_CASE_=[3, 3, 5],    SCREAMING_SNAKE_CASE_=[32, 16, 24],    SCREAMING_SNAKE_CASE_=[16, 24, 40],    SCREAMING_SNAKE_CASE_=[1, 1, 2],    SCREAMING_SNAKE_CASE_=[1, 1, 2],    SCREAMING_SNAKE_CASE_=[1, 6, 6],    SCREAMING_SNAKE_CASE_=True,    SCREAMING_SNAKE_CASE_=True,    SCREAMING_SNAKE_CASE_=37,    SCREAMING_SNAKE_CASE_="gelu",    SCREAMING_SNAKE_CASE_=10,    )  ->	List[Any]:
            UpperCamelCase					:						Optional[int]					=			parent
            UpperCamelCase					:						Any					=			batch_size
            UpperCamelCase					:						Union[str, Any]					=			image_size
            UpperCamelCase					:						Tuple					=			num_channels
            UpperCamelCase					:						Tuple					=			kernel_sizes
            UpperCamelCase					:						str					=			in_channels
            UpperCamelCase					:						List[str]					=			out_channels
            UpperCamelCase					:						Any					=			strides
            UpperCamelCase					:						List[str]					=			num_block_repeats
            UpperCamelCase					:						List[Any]					=			expand_ratios
            UpperCamelCase					:						List[str]					=			is_training
            UpperCamelCase					:						Dict					=			hidden_act
            UpperCamelCase					:						Optional[int]					=			num_labels
            UpperCamelCase					:						List[Any]					=			use_labels
         def       snake_case_ (    self )  ->	Union[str, Any]:
            UpperCamelCase					:						int					=			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )
  
            UpperCamelCase					:						List[Any]					=			None
            if self.use_labels:
               UpperCamelCase					:						Optional[int]					=			ids_tensor([self.batch_size],    self.num_labels )
  
            UpperCamelCase					:						Any					=			self.get_config()
            return config, pixel_values, labels
         def       snake_case_ (    self )  ->	List[str]:
            return EfficientNetConfig(
                num_channels=self.num_channels,    kernel_sizes=self.kernel_sizes,    in_channels=self.in_channels,    out_channels=self.out_channels,    strides=self.strides,    num_block_repeats=self.num_block_repeats,    expand_ratios=self.expand_ratios,    hidden_act=self.hidden_act,    num_labels=self.num_labels,    )
         def       snake_case_ (    self,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ )  ->	Any:
            UpperCamelCase					:						List[Any]					=			EfficientNetModel(config=SCREAMING_SNAKE_CASE_ )
            model.to(SCREAMING_SNAKE_CASE_ )
            model.eval()
            UpperCamelCase					:						Optional[Any]					=			model(SCREAMING_SNAKE_CASE_ )
            # expected last hidden states: B, C, H // 4, W // 4
            self.parent.assertEqual(
                result.last_hidden_state.shape,    (self.batch_size, config.hidden_dim, self.image_size // 4, self.image_size // 4),    )
         def       snake_case_ (    self,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ )  ->	Optional[Any]:
            UpperCamelCase					:						Tuple					=			EfficientNetForImageClassification(SCREAMING_SNAKE_CASE_ )
            model.to(SCREAMING_SNAKE_CASE_ )
            model.eval()
            UpperCamelCase					:						Any					=			model(SCREAMING_SNAKE_CASE_,    labels=SCREAMING_SNAKE_CASE_ )
            self.parent.assertEqual(result.logits.shape,    (self.batch_size, self.num_labels) )
  
  
  
  
  
  
         def       snake_case_ (    self )  ->	Any:
            UpperCamelCase					:						Tuple					=			self.prepare_config_and_inputs()
            UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase					:						List[str]					=			config_and_inputs
            UpperCamelCase					:						Optional[Any]					=			{'pixel_values': pixel_values}
            return config, inputs_dict
  
  
  
  
  
  
  @require_torch
  class        lowerCAmelCase_	(						a__ ,					a__ ,					unittest.TestCase							):
         UpperCAmelCase__       :      List[str]       =						(EfficientNetModel, EfficientNetForImageClassification) if is_torch_available() else ()
         UpperCAmelCase__       :      str       =						(
             {"feature-extraction": EfficientNetModel, "image-classification": EfficientNetForImageClassification}
             if is_torch_available()
             else {}
         )
  
         UpperCAmelCase__       :      Any       =						False
         UpperCAmelCase__       :      Optional[Any]       =						False
         UpperCAmelCase__       :      Optional[Any]       =						False
         UpperCAmelCase__       :      str       =						False
         UpperCAmelCase__       :      List[str]       =						False
         def       snake_case_ (    self )  ->	List[Any]:
            UpperCamelCase					:						Tuple					=			EfficientNetModelTester(self )
            UpperCamelCase					:						int					=			ConfigTester(
                self,    config_class=SCREAMING_SNAKE_CASE_,    has_text_modality=SCREAMING_SNAKE_CASE_,    hidden_size=37 )
         def       snake_case_ (    self )  ->	Optional[Any]:
            self.create_and_test_config_common_properties()
            self.config_tester.create_and_test_config_to_json_string()
            self.config_tester.create_and_test_config_to_json_file()
            self.config_tester.create_and_test_config_from_and_save_pretrained()
            self.config_tester.create_and_test_config_with_num_labels()
            self.config_tester.check_config_can_be_init_without_params()
            self.config_tester.check_config_arguments_init()
         def       snake_case_ (    self )  ->	str:
            return
         @unittest.skip(reason='EfficientNet does not use inputs_embeds' )
         def       snake_case_ (    self )  ->	List[Any]:
            pass
         @unittest.skip(reason='EfficientNet does not support input and output embeddings' )
         def       snake_case_ (    self )  ->	Tuple:
            pass
         @unittest.skip(reason='EfficientNet does not use feedforward chunking' )
         def       snake_case_ (    self )  ->	str:
            pass
         def       snake_case_ (    self )  ->	str:
            UpperCamelCase			,  UpperCamelCase					:						Optional[int]					=			self.model_tester.prepare_config_and_inputs_for_common()
  
            for model_class in self.all_model_classes:
               UpperCamelCase					:						Union[str, Any]					=			model_class(SCREAMING_SNAKE_CASE_ )
               UpperCamelCase					:						Optional[int]					=			inspect.signature(model.forward )
               # signature.parameters is an OrderedDict => so arg_names order is deterministic
               UpperCamelCase					:						Any					=			[*signature.parameters.keys()]
  
               UpperCamelCase					:						Optional[int]					=			['pixel_values']
               self.assertListEqual(arg_names[:1],    SCREAMING_SNAKE_CASE_ )
         def       snake_case_ (    self )  ->	Union[str, Any]:
            UpperCamelCase					:						List[str]					=			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_ )
         def       snake_case_ (    self )  ->	List[str]:
            def check_hidden_states_output(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ ):
               UpperCamelCase					:						Union[str, Any]					=			model_class(SCREAMING_SNAKE_CASE_ )
               model.to(SCREAMING_SNAKE_CASE_ )
               model.eval()
  
               with torch.no_grad():
                  UpperCamelCase					:						str					=			model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ ) )
  
               UpperCamelCase					:						Union[str, Any]					=			outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
               UpperCamelCase					:						str					=			sum(config.num_block_repeats ) * 4
               self.assertEqual(len(SCREAMING_SNAKE_CASE_ ),    SCREAMING_SNAKE_CASE_ )
  
               # EfficientNet's feature maps are of shape (batch_size, num_channels, height, width)
               self.assertListEqual(
                   list(hidden_states[0].shape[-2:] ),    [self.model_tester.image_size // 2, self.model_tester.image_size // 2],    )
  
            UpperCamelCase			,  UpperCamelCase					:						Tuple					=			self.model_tester.prepare_config_and_inputs_for_common()
  
            for model_class in self.all_model_classes:
               UpperCamelCase					:						int					=			True
               check_hidden_states_output(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ )
  
               # check that output_hidden_states also work using config
               del inputs_dict["output_hidden_states"]
               UpperCamelCase					:						Union[str, Any]					=			True
  
               check_hidden_states_output(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ )
         def       snake_case_ (    self )  ->	str:
            UpperCamelCase					:						Optional[Any]					=			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE_ )
         @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.' )
         def       snake_case_ (    self )  ->	Dict:
            pass
         @slow
         def       snake_case_ (    self )  ->	Any:
            for model_name in EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               UpperCamelCase					:						Union[str, Any]					=			EfficientNetModel.from_pretrained(SCREAMING_SNAKE_CASE_ )
               self.assertIsNotNone(SCREAMING_SNAKE_CASE_ )
  
  
  
  
  
  
         @is_pipeline_test
         @require_vision
         @slow
         def       snake_case_ (    self )  ->	Optional[int]:
            super().test_pipeline_image_classification()
  
  
  
  
  
  
  def 	UpperCamelCase			(     )			->  str:
     UpperCamelCase					:						Optional[Any]					=			Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'			)
     return image
  
  
  
  @require_torch
  @require_vision
  class        lowerCAmelCase_	(						unittest.TestCase							):
         @cached_property
         def       snake_case_ (    self )  ->	List[str]:
            return AutoImageProcessor.from_pretrained('google/efficientnet-b7' ) if is_vision_available() else None
  
  
  
  
  
  
         @slow
         def       snake_case_ (    self )  ->	List[Any]:
            UpperCamelCase					:						str					=			EfficientNetForImageClassification.from_pretrained('google/efficientnet-b7' ).to(SCREAMING_SNAKE_CASE_ )
  
            UpperCamelCase					:						List[str]					=			self.default_image_processor
            UpperCamelCase					:						Optional[Any]					=			prepare_img()
            UpperCamelCase					:						Tuple					=			image_processor(images=SCREAMING_SNAKE_CASE_,    return_tensors='pt' ).to(SCREAMING_SNAKE_CASE_ )
  
            # forward pass
            with torch.no_grad():
               UpperCamelCase					:						List[Any]					=			model(**SCREAMING_SNAKE_CASE_ )
  
            # verify the logits
            UpperCamelCase					:						str					=			torch.Size((1, 1000) )
            self.assertEqual(outputs.logits.shape,    SCREAMING_SNAKE_CASE_ )
  
            UpperCamelCase					:						Tuple					=			torch.tensor([0.00_01, 0.00_02, 0.00_02] ).to(SCREAMING_SNAKE_CASE_ )
            self.assertTrue(torch.allclose(outputs.logits[0, :3],    SCREAMING_SNAKE_CASE_,    atol=1e-4 ) )
  
  
  
  
style_context: 
  
  
  
  from typing import TYPE_CHECKING
  
  from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available
  
  
  __UpperCAmelCase      = {
      '''configuration_deta''': ['''DETA_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''DetaConfig'''],
  }
  
  try:
      if not is_vision_available():
          raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
      pass
  else:
      __UpperCAmelCase      = ['''DetaImageProcessor''']
  
  try:
      if not is_torch_available():
          raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
      pass
  else:
      __UpperCAmelCase      = [
          '''DETA_PRETRAINED_MODEL_ARCHIVE_LIST''',
          '''DetaForObjectDetection''',
          '''DetaModel''',
          '''DetaPreTrainedModel''',
      ]
  
  
  if TYPE_CHECKING:
      from .configuration_deta import DETA_PRETRAINED_CONFIG_ARCHIVE_MAP, DetaConfig
  
      try:
          if not is_vision_available():
              raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
          pass
      else:
          from .image_processing_deta import DetaImageProcessor
  
      try:
          if not is_torch_available():
              raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
          pass
      else:
          from .modeling_deta import (
              DETA_PRETRAINED_MODEL_ARCHIVE_LIST,
              DetaForObjectDetection,
              DetaModel,
              DetaPreTrainedModel,
          )
  
  else:
      import sys
  
      __UpperCAmelCase      = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
  
  
  
  