





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







import inspect
import os
import unittest

import torch

import accelerate
from accelerate import debug_launcher
from accelerate.test_utils import (
    execute_subprocess_async,
    require_cpu,
    require_multi_gpu,
    require_single_gpu,
    test_sync,
)
from accelerate.utils import patch_environment

class   __snake_case				(			unittest.TestCase   ):






    '''simple docstring'''





    def 	A		(   self						:		int							):

      """simple docstring"""





      __lowerCAmelCase			=				inspect.getfile(accelerate.test_utils							)
      __lowerCAmelCase			=				os.path.sep.join(mod_file.split(os.path.sep							)[:-1] + ['''scripts''', '''test_sync.py''']							)





    @require_cpu
    def 	A		(   self						:		str							):

      """simple docstring"""





      debug_launcher(test_sync.main			,						num_processes=1							)





    @require_cpu
    def 	A		(   self						:		List[str]							):

      """simple docstring"""





      debug_launcher(test_sync.main							)





    @require_single_gpu
    def 	A		(   self						:		Optional[Any]							):

      """simple docstring"""





      test_sync.main()





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

      """simple docstring"""





      print(f'''Found {torch.cuda.device_count()} devices.'''							)
      __lowerCAmelCase			=				['''torchrun''', f'''--nproc_per_node={torch.cuda.device_count()}''', self.test_file_path]
      with patch_environment(omp_num_threads=1							):
        execute_subprocess_async(snake_case			,						env=os.environ.copy()							)
