





"""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    )    )



_A		:					Union[str, Any]          =							1_000



def      __lowerCAmelCase    (				snake_case						:     float			)							->				float:
   return x * x



def      __lowerCAmelCase    (				snake_case						:     Optional[int]    ,   snake_case						:     float    ,   snake_case						:     float    ,   snake_case						:     int = 4			)							->				float:
   assert callable(
       snake_case			), f'the function(object) passed should be callable your input : {function}'
   assert isinstance(snake_case    ,   (float, int)			), f'a should be float or integer your input : {a}'
   assert isinstance(function(snake_case			)    ,   (float, int)			), (
       "the function should return integer or float return type of your function, "
       f'{type(snake_case			)}'
   )
   assert isinstance(snake_case    ,   (float, int)			), f'b should be float or integer your input : {b}'
   assert (
       isinstance(snake_case    ,   snake_case			) and precision > 0
   ), f'precision should be positive integer your input : {precision}'

   # just applying the formula of simpson for approximate integration written in
   # mentioned article in first comment of this file and above this function

   __lowerCamelCase:					List[str]	 =						(b - a) / N_STEPS
   __lowerCamelCase:					Optional[Any]	 =						function(snake_case			) + function(snake_case			)

   for i in range(1    ,   snake_case			):
      __lowerCamelCase:					Dict	 =						a + h * i
      result += function(snake_case			) * (4 if i % 2 else 2)

   result *= h / 3
   return round(snake_case    ,   snake_case			)


if __name__ == "__main__":
   import doctest

   doctest.testmod()


