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

   def __init__(self     ,				A     ,				A=1_3     ,				A=3_2     ,				A=3     ,				A=[3, 3, 5]     ,				A=[3_2, 1_6, 2_4]     ,				A=[1_6, 2_4, 4_0]     ,				A=[1, 1, 2]     ,				A=[1, 1, 2]     ,				A=[1, 6, 6]     ,				A=True     ,				A=True     ,				A=3_7     ,				A="gelu"     ,				A=1_0     ,				):
        lowerCamelCase_   : Tuple       =						parent
        lowerCamelCase_   : Union[str, Any]       =						batch_size
        lowerCamelCase_   : str       =						image_size
        lowerCamelCase_   : Optional[int]       =						num_channels
        lowerCamelCase_   : List[Any]       =						kernel_sizes
        lowerCamelCase_   : int       =						in_channels
        lowerCamelCase_   : str       =						out_channels
        lowerCamelCase_   : Any       =						strides
        lowerCamelCase_   : str       =						num_block_repeats
        lowerCamelCase_   : List[Any]       =						expand_ratios
        lowerCamelCase_   : Optional[int]       =						is_training
        lowerCamelCase_   : int       =						hidden_act
        lowerCamelCase_   : str       =						num_labels
        lowerCamelCase_   : List[str]       =						use_labels

   def     UpperCAmelCase__	(self ):
        lowerCamelCase_   : Union[str, Any]       =						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

        lowerCamelCase_   : List[str]       =						None
        if self.use_labels:
             lowerCamelCase_   : Tuple       =						ids_tensor([self.batch_size]     ,				self.num_labels )

        lowerCamelCase_   : str       =						self.get_config()
        return config, pixel_values, labels

   def     UpperCAmelCase__	(self ):
        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     UpperCAmelCase__	(self     ,				A     ,				A     ,				A ):
        lowerCamelCase_   : Union[str, Any]       =						EfficientNetModel(config=A )
        model.to(A )
        model.eval()
        lowerCamelCase_   : Any       =						model(A )
        # 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     UpperCAmelCase__	(self     ,				A     ,				A     ,				A ):
        lowerCamelCase_   : Optional[int]       =						EfficientNetForImageClassification(A )
        model.to(A )
        model.eval()
        lowerCamelCase_   : Dict       =						model(A     ,				labels=A )
        self.parent.assertEqual(result.logits.shape     ,				(self.batch_size, self.num_labels) )






   def     UpperCAmelCase__	(self ):
        lowerCamelCase_   : int       =						self.prepare_config_and_inputs()
        lowerCamelCase_   : int       =						config_and_inputs
        lowerCamelCase_   : Optional[Any]       =						{'''pixel_values''': pixel_values}
        return config, inputs_dict

@require_torch
class 		__lowercase			(					_lowercase ,       _lowercase ,       unittest.TestCase      ):
   lowerCamelCase     :						Dict		 =     (EfficientNetModel, EfficientNetForImageClassification) if is_torch_available() else ()
   lowerCamelCase     :						Tuple		 =     (
       {"feature-extraction": EfficientNetModel, "image-classification": EfficientNetForImageClassification}
       if is_torch_available()
       else {}
   )

   lowerCamelCase     :						Optional[Any]		 =     False
   lowerCamelCase     :						List[Any]		 =     False
   lowerCamelCase     :						List[Any]		 =     False
   lowerCamelCase     :						Dict		 =     False
   lowerCamelCase     :						str		 =     False

   def     UpperCAmelCase__	(self ):
        lowerCamelCase_   : Tuple       =						EfficientNetModelTester(self )
        lowerCamelCase_   : Optional[int]       =						ConfigTester(
            self     ,				config_class=A     ,				has_text_modality=A     ,				hidden_size=3_7 )

   def     UpperCAmelCase__	(self ):
        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     UpperCAmelCase__	(self ):
        return

   @unittest.skip(reason='''EfficientNet does not use inputs_embeds''' )
   def     UpperCAmelCase__	(self ):
        pass

   @unittest.skip(reason='''EfficientNet does not support input and output embeddings''' )
   def     UpperCAmelCase__	(self ):
        pass

   @unittest.skip(reason='''EfficientNet does not use feedforward chunking''' )
   def     UpperCAmelCase__	(self ):
        pass

   def     UpperCAmelCase__	(self ):
        lowerCamelCase_   : Optional[Any]       =						self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
             lowerCamelCase_   : int       =						model_class(A )
             lowerCamelCase_   : Any       =						inspect.signature(model.forward )
             # signature.parameters is an OrderedDict => so arg_names order is deterministic
             lowerCamelCase_   : Optional[int]       =						[*signature.parameters.keys()]

             lowerCamelCase_   : Union[str, Any]       =						['''pixel_values''']
             self.assertListEqual(arg_names[:1]     ,				A )

   def     UpperCAmelCase__	(self ):
        lowerCamelCase_   : Any       =						self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*A )

   def     UpperCAmelCase__	(self ):
        def check_hidden_states_output(A     ,				A     ,				A ):
             lowerCamelCase_   : int       =						model_class(A )
             model.to(A )
             model.eval()

             with torch.no_grad():
                  lowerCamelCase_   : Any       =						model(**self._prepare_for_class(A     ,				A ) )

             lowerCamelCase_   : Optional[int]       =						outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
             lowerCamelCase_   : int       =						sum(config.num_block_repeats ) * 4
             self.assertEqual(len(A )     ,				A )

             # 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]     ,				)

        lowerCamelCase_   : int       =						self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
             lowerCamelCase_   : Optional[int]       =						True
             check_hidden_states_output(A     ,				A     ,				A )

             # check that output_hidden_states also work using config
             del inputs_dict["output_hidden_states"]
             lowerCamelCase_   : Dict       =						True

             check_hidden_states_output(A     ,				A     ,				A )

   def     UpperCAmelCase__	(self ):
        lowerCamelCase_   : Optional[int]       =						self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*A )

   @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.''' )
   def     UpperCAmelCase__	(self ):
        pass

   @slow
   def     UpperCAmelCase__	(self ):
        for model_name in EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             lowerCamelCase_   : Optional[int]       =						EfficientNetModel.from_pretrained(A )
             self.assertIsNotNone(A )






   @is_pipeline_test
   @require_vision
   @slow
   def     UpperCAmelCase__	(self ):
        super().test_pipeline_image_classification()




def lowercase_		(				)       ->							List[Any]:
     '''simple docstring'''

     lowerCamelCase_   : Union[str, Any]       =						Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''			)
     return image






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

   @cached_property
   def     UpperCAmelCase__	(self ):
        return AutoImageProcessor.from_pretrained('''google/efficientnet-b7''' ) if is_vision_available() else None






   @slow
   def     UpperCAmelCase__	(self ):
        lowerCamelCase_   : List[str]       =						EfficientNetForImageClassification.from_pretrained('''google/efficientnet-b7''' ).to(A )

        lowerCamelCase_   : List[Any]       =						self.default_image_processor
        lowerCamelCase_   : Dict       =						prepare_img()
        lowerCamelCase_   : Tuple       =						image_processor(images=A     ,				return_tensors='''pt''' ).to(A )

        # forward pass
        with torch.no_grad():
             lowerCamelCase_   : Tuple       =						model(**A )

        # verify the logits
        lowerCamelCase_   : int       =						torch.Size((1, 1_0_0_0) )
        self.assertEqual(outputs.logits.shape     ,				A )

        lowerCamelCase_   : Tuple       =						torch.tensor([0.00_01, 0.00_02, 0.00_02] ).to(A )
        self.assertTrue(torch.allclose(outputs.logits[0, :3]     ,				A     ,				atol=1E-4 ) )




'''simple docstring'''


from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_torch_available,
    is_vision_available,
)


__lowercase							:				List[str]					=       {
    '''configuration_sam''': [
        '''SAM_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''SamConfig''',
        '''SamMaskDecoderConfig''',
        '''SamPromptEncoderConfig''',
        '''SamVisionConfig''',
    ],
    '''processing_sam''': ['''SamProcessor'''],
}


try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					__lowercase							:				List[Any]					=       [
					    '''SAM_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''SamModel''',
					    '''SamPreTrainedModel''',
					]
try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					__lowercase							:				int					=       [
					    '''TF_SAM_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''TFSamModel''',
					    '''TFSamPreTrainedModel''',
					]
try:
					if not is_vision_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					__lowercase							:				str					=       ['''SamImageProcessor''']


if TYPE_CHECKING:
					from .configuration_sam import (
					    SAM_PRETRAINED_CONFIG_ARCHIVE_MAP,
					    SamConfig,
					    SamMaskDecoderConfig,
					    SamPromptEncoderConfig,
					    SamVisionConfig,
					)
					from .processing_sam import SamProcessor

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_sam import SAM_PRETRAINED_MODEL_ARCHIVE_LIST, SamModel, SamPreTrainedModel

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_sam import TF_SAM_PRETRAINED_MODEL_ARCHIVE_LIST, TFSamModel, TFSamPreTrainedModel

					try:
										if not is_vision_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .image_processing_sam import SamImageProcessor

else:
					import sys

					__lowercase							:				List[str]					=       _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)


