





"""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 					_UpperCAmelCase    :



      '''simple docstring'''

      def __init__(	self   , snake_case_   , snake_case_=1_3   , snake_case_=3_2   , snake_case_=3   , snake_case_=[3, 3, 5]   , snake_case_=[3_2, 1_6, 2_4]   , snake_case_=[1_6, 2_4, 4_0]   , snake_case_=[1, 1, 2]   , snake_case_=[1, 1, 2]   , snake_case_=[1, 6, 6]   , snake_case_=True   , snake_case_=True   , snake_case_=3_7   , snake_case_="gelu"   , snake_case_=1_0   , ):

        """simple docstring"""

        A_    :			int									=    parent
        A_    :			Dict									=    batch_size
        A_    :			Union[str, Any]									=    image_size
        A_    :			Optional[Any]									=    num_channels
        A_    :			Optional[Any]									=    kernel_sizes
        A_    :			List[Any]									=    in_channels
        A_    :			Tuple									=    out_channels
        A_    :			List[Any]									=    strides
        A_    :			Optional[Any]									=    num_block_repeats
        A_    :			Any									=    expand_ratios
        A_    :			Optional[int]									=    is_training
        A_    :			Tuple									=    hidden_act
        A_    :			Union[str, Any]									=    num_labels
        A_    :			str									=    use_labels

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

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

        A_    :			Optional[int]									=    None
        if self.use_labels:
          A_    :			int									=    ids_tensor([self.batch_size]   , self.num_labels    )

        A_    :			List[Any]									=    self.get_config()
        return config, pixel_values, labels

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        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    lowerCamelCase_     (	self   , snake_case_   , snake_case_   , snake_case_    ):

        """simple docstring"""

        A_    :			List[str]									=    EfficientNetModel(config=snake_case_    )
        model.to(snake_case_    )
        model.eval()
        A_    :			Dict									=    model(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    lowerCamelCase_     (	self   , snake_case_   , snake_case_   , snake_case_    ):

        """simple docstring"""

        A_    :			int									=    EfficientNetForImageClassification(snake_case_    )
        model.to(snake_case_    )
        model.eval()
        A_    :			Optional[int]									=    model(snake_case_   , labels=snake_case_    )
        self.parent.assertEqual(result.logits.shape   , (self.batch_size, self.num_labels)    )

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_    :			int									=    self.prepare_config_and_inputs()
        A_		,			A_		,			A_    :			List[str]									=    config_and_inputs
        A_    :			Tuple									=    {'pixel_values': pixel_values}
        return config, inputs_dict


@require_torch
class 					_UpperCAmelCase    (  UpperCAmelCase__     ,  UpperCAmelCase__     ,  unittest.TestCase						):



      '''simple docstring'''
      lowercase_ :					Union[str, Any]             =  (EfficientNetModel, EfficientNetForImageClassification) if is_torch_available() else ()
      lowercase_ :					List[str]             =  (
          {"""feature-extraction""": EfficientNetModel, """image-classification""": EfficientNetForImageClassification}
          if is_torch_available()
          else {}
      )

      lowercase_ :					Optional[Any]             =  False
      lowercase_ :					Optional[int]             =  False
      lowercase_ :					Optional[int]             =  False
      lowercase_ :					Tuple             =  False
      lowercase_ :					Optional[int]             =  False

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_    :			List[Any]									=    EfficientNetModelTester(self    )
        A_    :			List[Any]									=    ConfigTester(
            self   , config_class=snake_case_   , has_text_modality=snake_case_   , hidden_size=3_7    )

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        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    lowerCamelCase_     (	self    ):

        """simple docstring"""

        return

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

        """simple docstring"""

        pass

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

        """simple docstring"""

        pass

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

        """simple docstring"""

        pass

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_		,			A_    :			str									=    self.model_tester.prepare_config_and_inputs_for_common()

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

          A_    :			Tuple									=    ['pixel_values']
          self.assertListEqual(arg_names[:1]   , snake_case_    )

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_    :			List[Any]									=    self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*snake_case_    )

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        def check_hidden_states_output(snake_case_   , snake_case_   , snake_case_    ):
          A_    :			int									=    model_class(snake_case_    )
          model.to(snake_case_    )
          model.eval()

          with torch.no_grad():
            A_    :			List[Any]									=    model(**self._prepare_for_class(snake_case_   , snake_case_    )    )

          A_    :			Dict									=    outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
          A_    :			List[str]									=    sum(config.num_block_repeats    ) * 4
          self.assertEqual(len(snake_case_    )   , 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]   , )

        A_		,			A_    :			str									=    self.model_tester.prepare_config_and_inputs_for_common()

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

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

          check_hidden_states_output(snake_case_   , snake_case_   , snake_case_    )

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_    :			Optional[Any]									=    self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*snake_case_    )

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

        """simple docstring"""

        pass

      @slow
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        for model_name in EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          A_    :			List[Any]									=    EfficientNetModel.from_pretrained(snake_case_    )
          self.assertIsNotNone(snake_case_    )

      @is_pipeline_test
      @require_vision
      @slow
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        super().test_pipeline_image_classification()





def 		UpperCAmelCase__						(	):






  """simple docstring"""





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





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



      '''simple docstring'''

      @cached_property
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        return AutoImageProcessor.from_pretrained('google/efficientnet-b7'    ) if is_vision_available() else None

      @slow
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_    :			Dict									=    EfficientNetForImageClassification.from_pretrained('google/efficientnet-b7'    ).to(snake_case_    )

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

        # forward pass
        with torch.no_grad():
          A_    :			Optional[int]									=    model(**snake_case_    )

        # verify the logits
        A_    :			List[Any]									=    torch.Size((1, 1_0_0_0)    )
        self.assertEqual(outputs.logits.shape   , snake_case_    )

        A_    :			Optional[int]									=    torch.tensor([0.00_01, 0.00_02, 0.00_02]    ).to(snake_case_    )
        self.assertTrue(torch.allclose(outputs.logits[0, :3]   , snake_case_   , atol=1E-4    )    )





import inspect
import unittest

from transformers import is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

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 MODEL_MAPPING, PoolFormerConfig, PoolFormerForImageClassification, PoolFormerModel
    from transformers.models.poolformer.modeling_poolformer import POOLFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
    from PIL import Image

    from transformers import PoolFormerImageProcessor


class        UpperCAmelCase__				(							UpperCAmelCase__				):



     '''simple docstring'''
     def        lowerCAmelCase__  (				self	):
            a			   =self.config_class(**self.inputs_dict	)
            self.parent.assertTrue(hasattr(_lowerCAmelCase ,    """hidden_sizes"""	)	)
            self.parent.assertTrue(hasattr(_lowerCAmelCase ,    """num_encoder_blocks"""	)	)



class        UpperCAmelCase__				:



     '''simple docstring'''
     def __init__(				self ,    _lowerCAmelCase ,    _lowerCAmelCase=13 ,    _lowerCAmelCase=64 ,    _lowerCAmelCase=3 ,    _lowerCAmelCase=4 ,    _lowerCAmelCase=[2, 2, 2, 2] ,    _lowerCAmelCase=[8, 4, 2, 1] ,    _lowerCAmelCase=[16, 32, 64, 128] ,    _lowerCAmelCase=[1, 4, 8, 16] ,    _lowerCAmelCase=False ,    _lowerCAmelCase=True ,    _lowerCAmelCase="gelu" ,    _lowerCAmelCase=0.1 ,    _lowerCAmelCase=0.02 ,    _lowerCAmelCase=3 ,    _lowerCAmelCase=None ,    ):
            a			   =parent
            a			   =batch_size
            a			   =image_size
            a			   =num_channels
            a			   =num_encoder_blocks
            a			   =sr_ratios
            a			   =depths
            a			   =hidden_sizes
            a			   =downsampling_rates
            a			   =is_training
            a			   =use_labels
            a			   =hidden_act
            a			   =hidden_dropout_prob
            a			   =initializer_range
            a			   =num_labels
            a			   =scope
     def        lowerCAmelCase__  (				self	):
            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.image_size, self.image_size] ,    self.num_labels	)

            a			   =PoolFormerConfig(
                image_size=self.image_size ,    num_channels=self.num_channels ,    num_encoder_blocks=self.num_encoder_blocks ,    depths=self.depths ,    hidden_sizes=self.hidden_sizes ,    hidden_act=self.hidden_act ,    hidden_dropout_prob=self.hidden_dropout_prob ,    initializer_range=self.initializer_range ,    )

            return config, pixel_values, labels
     def        lowerCAmelCase__  (				self ,    _lowerCAmelCase ,    _lowerCAmelCase ,    _lowerCAmelCase	):
            a			   =PoolFormerModel(config=_lowerCAmelCase	)
            model.to(_lowerCAmelCase	)
            model.eval()
            a			   =model(_lowerCAmelCase	)
            a			   =a			   =self.image_size // 32.0
            self.parent.assertEqual(
                result.last_hidden_state.shape ,    (self.batch_size, self.hidden_sizes[-1], expected_height, expected_width)	)






     def        lowerCAmelCase__  (				self	):
            a			   =self.prepare_config_and_inputs()
            a   ,      a   ,      a			   =config_and_inputs
            a			   ={"""pixel_values""": pixel_values}
            return config, inputs_dict



@require_torch
class        UpperCAmelCase__				(							UpperCAmelCase__      ,		UpperCAmelCase__      ,		unittest.TestCase				):



     '''simple docstring'''
     _SCREAMING_SNAKE_CASE      :					Tuple     					=    (PoolFormerModel, PoolFormerForImageClassification) if is_torch_available() else ()
     _SCREAMING_SNAKE_CASE      :					Any     					=    (
         {"feature-extraction": PoolFormerModel, "image-classification": PoolFormerForImageClassification}
         if is_torch_available()
         else {}
     )

     _SCREAMING_SNAKE_CASE      :					Union[str, Any]     					=    False
     _SCREAMING_SNAKE_CASE      :					Tuple     					=    False
     _SCREAMING_SNAKE_CASE      :					str     					=    False
     _SCREAMING_SNAKE_CASE      :					Optional[int]     					=    False
     _SCREAMING_SNAKE_CASE      :					Optional[int]     					=    False
     def        lowerCAmelCase__  (				self	):
            a			   =PoolFormerModelTester(self	)
            a			   =PoolFormerConfigTester(self ,    config_class=_lowerCAmelCase	)
     def        lowerCAmelCase__  (				self	):
            self.config_tester.run_common_tests()
     def        lowerCAmelCase__  (				self	):
            a			   =self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*_lowerCAmelCase	)
     @unittest.skip("""PoolFormer does not use inputs_embeds"""	)
     def        lowerCAmelCase__  (				self	):
            pass
     @unittest.skip("""PoolFormer does not have get_input_embeddings method and get_output_embeddings methods"""	)
     def        lowerCAmelCase__  (				self	):
            pass
     def        lowerCAmelCase__  (				self	):
            def check_hidden_states_output(_lowerCAmelCase ,    _lowerCAmelCase ,    _lowerCAmelCase	):
                   a			   =model_class(_lowerCAmelCase	)
                   model.to(_lowerCAmelCase	)
                   model.eval()

                   with torch.no_grad():
                          a			   =model(**self._prepare_for_class(_lowerCAmelCase ,    _lowerCAmelCase	)	)

                   a			   =outputs.hidden_states

                   a			   =self.model_tester.num_encoder_blocks
                   self.assertEqual(len(_lowerCAmelCase	) ,    _lowerCAmelCase	)

                   # verify the first hidden states (first block)
                   self.assertListEqual(
                       list(hidden_states[0].shape[-3:]	) ,    [
                           self.model_tester.hidden_sizes[0],
                           self.model_tester.image_size // 4,
                           self.model_tester.image_size // 4,
                       ] ,    )

            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(_lowerCAmelCase ,    _lowerCAmelCase ,    _lowerCAmelCase	)

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

                   check_hidden_states_output(_lowerCAmelCase ,    _lowerCAmelCase ,    _lowerCAmelCase	)
     def        lowerCAmelCase__  (				self	):
            if not self.model_tester.is_training:
                   return

            a   ,      a			   =self.model_tester.prepare_config_and_inputs_for_common()
            a			   =True

            for model_class in self.all_model_classes:
                   if model_class in get_values(_lowerCAmelCase	):
                          continue
                   a			   =model_class(_lowerCAmelCase	)
                   model.to(_lowerCAmelCase	)
                   model.train()
                   a			   =self._prepare_for_class(_lowerCAmelCase ,    _lowerCAmelCase ,    return_labels=_lowerCAmelCase	)
                   a			   =model(**_lowerCAmelCase	).loss
                   loss.backward()
     def        lowerCAmelCase__  (				self	):
            a   ,      a			   =self.model_tester.prepare_config_and_inputs_for_common()

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

                   a			   =["""pixel_values"""]
                   self.assertListEqual(arg_names[:1] ,    _lowerCAmelCase	)






     @slow
     def        lowerCAmelCase__  (				self	):
            for model_name in POOLFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                   a			   =PoolFormerModel.from_pretrained(_lowerCAmelCase	)
                   self.assertIsNotNone(_lowerCAmelCase	)





def 							lowerCamelCase    (							)->			Tuple:

       """simple docstring"""




       a			   =Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""      )
       return image






@require_torch
class        UpperCAmelCase__				(							unittest.TestCase				):



     '''simple docstring'''
     @slow
     def        lowerCAmelCase__  (				self	):
            a			   =PoolFormerImageProcessor()
            a			   =PoolFormerForImageClassification.from_pretrained("""sail/poolformer_s12"""	).to(_lowerCAmelCase	)

            a			   =image_processor(images=prepare_img() ,    return_tensors="""pt"""	).to(_lowerCAmelCase	)

            # forward pass
            with torch.no_grad():
                   a			   =model(**_lowerCAmelCase	)

            # verify the logits
            a			   =torch.Size((1, 1_000)	)
            self.assertEqual(outputs.logits.shape ,    _lowerCAmelCase	)

            a			   =torch.tensor([-0.61_13, 0.16_85, -0.04_92]	).to(_lowerCAmelCase	)
            self.assertTrue(torch.allclose(outputs.logits[0, :3] ,    _lowerCAmelCase ,    atol=1E-4	)	)
