






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							,					_A							,					_A=13							,					_A=32							,					_A=3							,					_A=[3, 3, 5]							,					_A=[32, 16, 24]							,					_A=[16, 24, 40]							,					_A=[1, 1, 2]							,					_A=[1, 1, 2]							,					_A=[1, 6, 6]							,					_A=True							,					_A=True							,					_A=37							,					_A="gelu"							,					_A=10							,					)	->						Tuple:

     """simple docstring"""



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


 def 	snake_case__			(		self)	->						Tuple:

     """simple docstring"""



     _UpperCAmelCase			: Optional[int]     					=			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

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

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


 def 	snake_case__			(		self)	->						Optional[Any]:

     """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 	snake_case__			(		self							,					_A							,					_A							,					_A)	->						Tuple:

     """simple docstring"""



     _UpperCAmelCase			: int     					=			EfficientNetModel(config=_A)
     model.to(_A)
     model.eval()
     _UpperCAmelCase			: 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 	snake_case__			(		self							,					_A							,					_A							,					_A)	->						List[str]:

     """simple docstring"""



     _UpperCAmelCase			: int     					=			EfficientNetForImageClassification(_A)
     model.to(_A)
     model.eval()
     _UpperCAmelCase			: Tuple     					=			model(_A							,					labels=_A)
     self.parent.assertEqual(result.logits.shape							,					(self.batch_size, self.num_labels))


 def 	snake_case__			(		self)	->						Dict:

     """simple docstring"""



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



@require_torch
class 							A_      (  __lowercase	,				__lowercase	,				unittest.TestCase     ):






 '''simple docstring'''




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

 _SCREAMING_SNAKE_CASE							:     str	=   False
 _SCREAMING_SNAKE_CASE							:     Union[str, Any]	=   False
 _SCREAMING_SNAKE_CASE							:     Dict	=   False
 _SCREAMING_SNAKE_CASE							:     Tuple	=   False
 _SCREAMING_SNAKE_CASE							:     Tuple	=   False


 def 	snake_case__			(		self)	->						Any:

     """simple docstring"""



     _UpperCAmelCase			: Any     					=			EfficientNetModelTester(self)
     _UpperCAmelCase			: Any     					=			ConfigTester(
         self							,					config_class=_A							,					has_text_modality=_A							,					hidden_size=37)


 def 	snake_case__			(		self)	->						List[Any]:

     """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 	snake_case__			(		self)	->						str:

     """simple docstring"""



     return


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

     """simple docstring"""



     pass


 @unittest.skip(reason='''EfficientNet does not support input and output embeddings''')
 def 	snake_case__			(		self)	->						List[Any]:

     """simple docstring"""



     pass


 @unittest.skip(reason='''EfficientNet does not use feedforward chunking''')
 def 	snake_case__			(		self)	->						str:

     """simple docstring"""



     pass


 def 	snake_case__			(		self)	->						Union[str, Any]:

     """simple docstring"""



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

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

         _UpperCAmelCase			: Optional[int]     					=			['''pixel_values''']
         self.assertListEqual(arg_names[:1]							,					_A)


 def 	snake_case__			(		self)	->						Any:

     """simple docstring"""



     _UpperCAmelCase			: Optional[int]     					=			self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*_A)


 def 	snake_case__			(		self)	->						Optional[int]:

     """simple docstring"""



     def check_hidden_states_output(_A							,					_A							,					_A):
         _UpperCAmelCase			: List[str]     					=			model_class(_A)
         model.to(_A)
         model.eval()

         with torch.no_grad():
             _UpperCAmelCase			: Any     					=			model(**self._prepare_for_class(_A							,					_A))

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

     _UpperCAmelCase					,	_UpperCAmelCase			: Optional[Any]     					=			self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
         _UpperCAmelCase			: Optional[int]     					=			True
         check_hidden_states_output(_A							,					_A							,					_A)

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

         check_hidden_states_output(_A							,					_A							,					_A)


 def 	snake_case__			(		self)	->						Any:

     """simple docstring"""



     _UpperCAmelCase			: Union[str, Any]     					=			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 	snake_case__			(		self)	->						Tuple:

     """simple docstring"""



     pass


 @slow
 def 	snake_case__			(		self)	->						List[str]:

     """simple docstring"""



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


 @is_pipeline_test
 @require_vision
 @slow
 def 	snake_case__			(		self)	->						Optional[int]:

     """simple docstring"""



     super().test_pipeline_image_classification()



def        _lowerCamelCase		(  ) ->   Optional[Any]:
    _UpperCAmelCase			: 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 	snake_case__			(		self)	->						List[Any]:

     """simple docstring"""



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


 @slow
 def 	snake_case__			(		self)	->						int:

     """simple docstring"""



     _UpperCAmelCase			: Dict     					=			EfficientNetForImageClassification.from_pretrained('''google/efficientnet-b7''').to(_A)

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

     # forward pass
     with torch.no_grad():
         _UpperCAmelCase			: int     					=			model(**_A)

     # verify the logits
     _UpperCAmelCase			: List[str]     					=			torch.Size((1, 1000))
     self.assertEqual(outputs.logits.shape							,					_A)

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












from unittest.mock import patch

import datasets
from datasets import Dataset

def        _lowerCamelCase		(  ) ->   Tuple:
    _UpperCAmelCase			: Union[str, Any]     					=			Dataset.from_dict({'''col_1''': [3, 2, 0, 1]}	)

    with patch('''tqdm.auto.tqdm'''	) as mock_tqdm:
        datasets.disable_progress_bar()
        dset.map(lambda __A	: {"col_2": x["col_1"] + 1}	)
        mock_tqdm.assert_not_called()

        mock_tqdm.reset_mock()

        datasets.enable_progress_bar()
        dset.map(lambda __A	: {"col_2": x["col_1"] + 1}	)
        mock_tqdm.assert_called()




