



'''simple docstring'''






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 							lowercase :


 """simple docstring"""


 def __init__(							self						,a_						,a_=13						,a_=32						,a_=3						,a_=[3, 3, 5]						,a_=[32, 16, 24]						,a_=[16, 24, 40]						,a_=[1, 1, 2]						,a_=[1, 1, 2]						,a_=[1, 6, 6]						,a_=True						,a_=True						,a_=37						,a_="gelu"						,a_=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						,a_						,a_						,a_							)	->     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						,a_						,a_						,a_							)	->     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						:		List[str]      =				config_and_inputs
        _UpperCAmelCase						:		Optional[Any]      =				{'pixel_values': pixel_values}
        return config, inputs_dict







@require_torch
class 							lowercase (						a__      ,      a__      ,      unittest.TestCase       ):


 """simple docstring"""


 UpperCAmelCase					=						(EfficientNetModel, EfficientNetForImageClassification) if is_torch_available() else ()
 UpperCAmelCase					=						(
     {"feature-extraction": EfficientNetModel, "image-classification": EfficientNetForImageClassification}
     if is_torch_available()
     else {}
 )

 UpperCAmelCase					=						False
 UpperCAmelCase					=						False
 UpperCAmelCase					=						False
 UpperCAmelCase					=						False
 UpperCAmelCase					=						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						:		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(a_						,a_						,a_							):
               _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						:		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 					snake_case_      (  )->	str:





       '''simple docstring'''


       _UpperCAmelCase						:		Optional[Any]      =				Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""	)
       return image



@require_torch
@require_vision
class 							lowercase (						unittest.TestCase       ):


 """simple docstring"""


 @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, 1_000)							)
        self.assertEqual(outputs.logits.shape						,SCREAMING_SNAKE_CASE_							)

        _UpperCAmelCase						:		Tuple      =				torch.tensor([0.0001, 0.0002, 0.0002]							).to(SCREAMING_SNAKE_CASE_							)
        self.assertTrue(torch.allclose(outputs.logits[0, :3]						,SCREAMING_SNAKE_CASE_						,atol=1E-4							)							)








'''simple docstring'''






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


A_							:				List[Any]						=			{
    """configuration_deta""": ["""DETA_PRETRAINED_CONFIG_ARCHIVE_MAP""", """DetaConfig"""],
}

try:
   if not is_vision_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   A_							:				Optional[int]						=			["""DetaImageProcessor"""]

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   A_							:				Optional[Any]						=			[
       """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

   A_							:				List[Any]						=			_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)



