






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







      '''simple docstring'''

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

       '''simple docstring'''



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




      def      a__				(self   ):

       '''simple docstring'''



       lowerCamelCase__	:     Optional[Any]								=		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

       lowerCamelCase__	:     Union[str, Any]								=		None
       if self.use_labels:
        lowerCamelCase__	:     int								=		ids_tensor([self.batch_size],	self.num_labels   )

       lowerCamelCase__	:     Optional[Any]								=		self.get_config()
       return config, pixel_values, labels




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

       '''simple docstring'''



       lowerCamelCase__	:     Union[str, Any]								=		EfficientNetModel(config=_A   )
       model.to(_A   )
       model.eval()
       lowerCamelCase__	:     List[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      a__				(self,	lowerCamelCase_,	lowerCamelCase_,	lowerCamelCase_   ):

       '''simple docstring'''



       lowerCamelCase__	:     Any								=		EfficientNetForImageClassification(_A   )
       model.to(_A   )
       model.eval()
       lowerCamelCase__	:     Optional[Any]								=		model(_A,	labels=_A   )
       self.parent.assertEqual(result.logits.shape,	(self.batch_size, self.num_labels)   )





      def      a__				(self   ):

       '''simple docstring'''



       lowerCamelCase__	:     Union[str, Any]								=		self.prepare_config_and_inputs()
       lowerCamelCase__	:     Any								=		config_and_inputs
       lowerCamelCase__	:     List[str]								=		{'pixel_values': pixel_values}
       return config, inputs_dict



@require_torch
class 						a_ (      snake_case_    ,		snake_case_    ,		unittest.TestCase					):







      '''simple docstring'''

      lowerCamelCase__			:							Optional[Any]					=      (EfficientNetModel, EfficientNetForImageClassification) if is_torch_available() else ()
      lowerCamelCase__			:							Optional[Any]					=      (
          {"""feature-extraction""": EfficientNetModel, """image-classification""": EfficientNetForImageClassification}
          if is_torch_available()
          else {}
      )

      lowerCamelCase__			:							Tuple					=      False
      lowerCamelCase__			:							List[str]					=      False
      lowerCamelCase__			:							Dict					=      False
      lowerCamelCase__			:							Union[str, Any]					=      False
      lowerCamelCase__			:							Union[str, Any]					=      False




      def      a__				(self   ):

       '''simple docstring'''



       lowerCamelCase__	:     List[Any]								=		EfficientNetModelTester(self   )
       lowerCamelCase__	:     int								=		ConfigTester(
           self,	config_class=_A,	has_text_modality=_A,	hidden_size=3_7   )




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

       '''simple docstring'''



       return




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

       '''simple docstring'''



       pass




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

       '''simple docstring'''



       pass




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

       '''simple docstring'''



       pass




      def      a__				(self   ):

       '''simple docstring'''



       lowerCamelCase__	:     int								=		self.model_tester.prepare_config_and_inputs_for_common()

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

        lowerCamelCase__	:     str								=		['pixel_values']
        self.assertListEqual(arg_names[:1],	_A   )




      def      a__				(self   ):

       '''simple docstring'''



       lowerCamelCase__	:     List[Any]								=		self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_A   )




      def      a__				(self   ):

       '''simple docstring'''



       def check_hidden_states_output(lowerCamelCase_,	lowerCamelCase_,	lowerCamelCase_   ):
        lowerCamelCase__	:     Union[str, Any]								=		model_class(_A   )
        model.to(_A   )
        model.eval()

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

        lowerCamelCase__	:     List[str]								=		outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
        lowerCamelCase__	:     Dict								=		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__	:     Optional[Any]								=		self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
        lowerCamelCase__	:     Any								=		True
        check_hidden_states_output(_A,	_A,	_A   )

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

        check_hidden_states_output(_A,	_A,	_A   )




      def      a__				(self   ):

       '''simple docstring'''



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

       '''simple docstring'''



       pass




      @slow
      def      a__				(self   ):

       '''simple docstring'''



       for model_name in EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        lowerCamelCase__	:     Optional[Any]								=		EfficientNetModel.from_pretrained(_A   )
        self.assertIsNotNone(_A   )





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

       '''simple docstring'''



       super().test_pipeline_image_classification()






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





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







      '''simple docstring'''

      @cached_property
      def      a__				(self   ):

       '''simple docstring'''



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





      @slow
      def      a__				(self   ):

       '''simple docstring'''



       lowerCamelCase__	:     Union[str, Any]								=		EfficientNetForImageClassification.from_pretrained('google/efficientnet-b7'   ).to(_A   )

       lowerCamelCase__	:     str								=		self.default_image_processor
       lowerCamelCase__	:     List[Any]								=		prepare_img()
       lowerCamelCase__	:     Optional[int]								=		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__	:     str								=		torch.tensor([0.0_001, 0.0_002, 0.0_002]   ).to(_A   )
       self.assertTrue(torch.allclose(outputs.logits[0, :3],	_A,	atol=1e-4   )   )


"""simple docstring"""







def     __UpperCAmelCase							(       UpperCAmelCase_       :							str    )				->     str:

	'''simple docstring'''





	return " ".join(sorted(set(sentence.split()    )    )    )


if __name__ == "__main__":
	import doctest

	doctest.testmod()





