





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






    '''simple docstring'''





    def __init__(   self						:		List[str]			,						snake_case						:		Union[str, Any]			,						snake_case						:		Tuple=13			,						snake_case						:		Dict=32			,						snake_case						:		Union[str, Any]=3			,						snake_case						:		int=[3, 3, 5]			,						snake_case						:		List[Any]=[32, 16, 24]			,						snake_case						:		Tuple=[16, 24, 40]			,						snake_case						:		int=[1, 1, 2]			,						snake_case						:		int=[1, 1, 2]			,						snake_case						:		List[Any]=[1, 6, 6]			,						snake_case						:		int=True			,						snake_case						:		Optional[int]=True			,						snake_case						:		Dict=37			,						snake_case						:		List[Any]="gelu"			,						snake_case						:		List[Any]=10			,						):

      """simple docstring"""





      __lowerCAmelCase			=				parent
      __lowerCAmelCase			=				batch_size
      __lowerCAmelCase			=				image_size
      __lowerCAmelCase			=				num_channels
      __lowerCAmelCase			=				kernel_sizes
      __lowerCAmelCase			=				in_channels
      __lowerCAmelCase			=				out_channels
      __lowerCAmelCase			=				strides
      __lowerCAmelCase			=				num_block_repeats
      __lowerCAmelCase			=				expand_ratios
      __lowerCAmelCase			=				is_training
      __lowerCAmelCase			=				hidden_act
      __lowerCAmelCase			=				num_labels
      __lowerCAmelCase			=				use_labels





    def 	A		(   self						:		Union[str, Any]							):

      """simple docstring"""





      __lowerCAmelCase			=				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

      __lowerCAmelCase			=				None
      if self.use_labels:
        __lowerCAmelCase			=				ids_tensor([self.batch_size]			,						self.num_labels							)

      __lowerCAmelCase			=				self.get_config()
      return config, pixel_values, labels





    def 	A		(   self						:		str							):

      """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 	A		(   self						:		Tuple			,						snake_case						:		Any			,						snake_case						:		Any			,						snake_case						:		Any							):

      """simple docstring"""





      __lowerCAmelCase			=				EfficientNetModel(config=snake_case							)
      model.to(snake_case							)
      model.eval()
      __lowerCAmelCase			=				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 	A		(   self						:		Optional[Any]			,						snake_case						:		Tuple			,						snake_case						:		Union[str, Any]			,						snake_case						:		Dict							):

      """simple docstring"""





      __lowerCAmelCase			=				EfficientNetForImageClassification(snake_case							)
      model.to(snake_case							)
      model.eval()
      __lowerCAmelCase			=				model(snake_case			,						labels=snake_case							)
      self.parent.assertEqual(result.logits.shape			,						(self.batch_size, self.num_labels)							)





    def 	A		(   self						:		Any							):

      """simple docstring"""





      __lowerCAmelCase			=				self.prepare_config_and_inputs()
      __lowerCAmelCase	,						__lowerCAmelCase	,						__lowerCAmelCase			=				config_and_inputs
      __lowerCAmelCase			=				{'''pixel_values''': pixel_values}
      return config, inputs_dict


@require_torch
class   __snake_case				(			_a       ,				_a       ,				unittest.TestCase   ):






    '''simple docstring'''
    _lowerCAmelCase     =	(EfficientNetModel, EfficientNetForImageClassification) if is_torch_available() else ()
    _lowerCAmelCase     =	(
        {"""feature-extraction""": EfficientNetModel, """image-classification""": EfficientNetForImageClassification}
        if is_torch_available()
        else {}
    )

    _lowerCAmelCase     =	False
    _lowerCAmelCase     =	False
    _lowerCAmelCase     =	False
    _lowerCAmelCase     =	False
    _lowerCAmelCase     =	False





    def 	A		(   self						:		Any							):

      """simple docstring"""





      __lowerCAmelCase			=				EfficientNetModelTester(self							)
      __lowerCAmelCase			=				ConfigTester(
          self			,						config_class=snake_case			,						has_text_modality=snake_case			,						hidden_size=37							)





    def 	A		(   self						:		int							):

      """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 	A		(   self						:		int							):

      """simple docstring"""





      return





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

      """simple docstring"""





      pass





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

      """simple docstring"""





      pass





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

      """simple docstring"""





      pass





    def 	A		(   self						:		List[str]							):

      """simple docstring"""





      __lowerCAmelCase	,						__lowerCAmelCase			=				self.model_tester.prepare_config_and_inputs_for_common()

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

        __lowerCAmelCase			=				['''pixel_values''']
        self.assertListEqual(arg_names[:1]			,						snake_case							)





    def 	A		(   self						:		str							):

      """simple docstring"""





      __lowerCAmelCase			=				self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*snake_case							)





    def 	A		(   self						:		Optional[int]							):

      """simple docstring"""





      def check_hidden_states_output(snake_case						:		Union[str, Any]			,						snake_case						:		str			,						snake_case						:		Any							):
        __lowerCAmelCase			=				model_class(snake_case							)
        model.to(snake_case							)
        model.eval()

        with torch.no_grad():
          __lowerCAmelCase			=				model(**self._prepare_for_class(snake_case			,						snake_case							)							)

        __lowerCAmelCase			=				outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
        __lowerCAmelCase			=				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]			,						)

      __lowerCAmelCase	,						__lowerCAmelCase			=				self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
        __lowerCAmelCase			=				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"]
        __lowerCAmelCase			=				True

        check_hidden_states_output(snake_case			,						snake_case			,						snake_case							)





    def 	A		(   self						:		Union[str, Any]							):

      """simple docstring"""





      __lowerCAmelCase			=				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 	A		(   self						:		Dict							):

      """simple docstring"""





      pass





    @slow
    def 	A		(   self						:		str							):

      """simple docstring"""





      for model_name in EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        __lowerCAmelCase			=				EfficientNetModel.from_pretrained(snake_case							)
        self.assertIsNotNone(snake_case							)





    @is_pipeline_test
    @require_vision
    @slow
    def 	A		(   self						:		str							):

      """simple docstring"""





      super().test_pipeline_image_classification()


def 					__SCREAMING_SNAKE_CASE  (							):



  '''simple docstring'''






  __lowerCAmelCase			=				Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''')
  return image




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






    '''simple docstring'''





    @cached_property
    def 	A		(   self						:		List[Any]							):

      """simple docstring"""





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





    @slow
    def 	A		(   self						:		Any							):

      """simple docstring"""





      __lowerCAmelCase			=				EfficientNetForImageClassification.from_pretrained('''google/efficientnet-b7'''							).to(snake_case							)

      __lowerCAmelCase			=				self.default_image_processor
      __lowerCAmelCase			=				prepare_img()
      __lowerCAmelCase			=				image_processor(images=snake_case			,						return_tensors='''pt'''							).to(snake_case							)

      # forward pass
      with torch.no_grad():
        __lowerCAmelCase			=				model(**snake_case							)

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

      __lowerCAmelCase			=				torch.tensor([0.0001, 0.0002, 0.0002]							).to(snake_case							)
      self.assertTrue(torch.allclose(outputs.logits[0, :3]			,						snake_case			,						atol=1e-4							)							)







class   __snake_case				:






    '''simple docstring'''





    def __init__(   self						:		Any							):

      """simple docstring"""





      __lowerCAmelCase			=				{}
      # indexmap keys are an index and it's values are the number at that index
      __lowerCAmelCase			=				{}





    def 	A		(   self						:		List[Any]			,						snake_case						:		list | str | range			,						snake_case						:		int							):

      """simple docstring"""





      if isinstance(snake_case			,						(range, str)							):
        __lowerCAmelCase			=				list(snake_case							)
      elif not isinstance(snake_case			,						snake_case							):
        raise TypeError(
            '''binary_search_delete() only accepts either a list, range or str'''							)

      __lowerCAmelCase			=				0
      __lowerCAmelCase			=				len(snake_case							) - 1

      while low <= high:
        __lowerCAmelCase			=				(low + high) // 2
        if array[mid] == item:
          array.pop(snake_case							)
          return array
        elif array[mid] < item:
          __lowerCAmelCase			=				mid + 1
        else:
          __lowerCAmelCase			=				mid - 1
      raise ValueError(
          '''Either the item is not in the array or the array was unsorted'''							)





    def 	A		(   self						:		Tuple			,						snake_case						:		list | str | range			,						snake_case						:		int							):

      """simple docstring"""





      if isinstance(snake_case			,						(range, str)							):
        __lowerCAmelCase			=				list(snake_case							)
      elif not isinstance(snake_case			,						snake_case							):
        raise TypeError(
            '''binary_search_insert() only accepts either a list, range or str'''							)

      __lowerCAmelCase			=				0
      __lowerCAmelCase			=				len(snake_case							) - 1

      while low <= high:
        __lowerCAmelCase			=				(low + high) // 2
        if array[mid] == index:
          # If the item already exists in the array,
          # insert it after the existing item
          array.insert(mid + 1			,						snake_case							)
          return array
        elif array[mid] < index:
          __lowerCAmelCase			=				mid + 1
        else:
          __lowerCAmelCase			=				mid - 1

        # If the item doesn't exist in the array, insert it at the appropriate position
      array.insert(snake_case			,						snake_case							)
      return array





    def 	A		(   self						:		Tuple			,						snake_case						:		int			,						snake_case						:		int							):

      """simple docstring"""





      if index in self.indexmap:
        __lowerCAmelCase			=				self.indexmap[index]
        if len(self.numbermap[n]							) == 1:
          del self.numbermap[n]
        else:
          __lowerCAmelCase			=				self.binary_search_delete(self.numbermap[n]			,						snake_case							)

        # Set new index
      __lowerCAmelCase			=				number

      # Number not seen before or empty so insert number value
      if number not in self.numbermap:
        __lowerCAmelCase			=				[index]

      # Here we need to perform a binary search insertion in order to insert
      # The item in the correct place
      else:
        __lowerCAmelCase			=				self.binary_search_insert(
            self.numbermap[number]			,						snake_case							)





    def 	A		(   self						:		List[str]			,						snake_case						:		int							):

      """simple docstring"""





      return self.numbermap.get(snake_case			,						[-1]							)[0]


if __name__ == "__main__":
      import doctest

      doctest.testmod()
