




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			:							Union[str, Any]    ,					A			:							Any    ,					A			:							int=13    ,					A			:							Dict=32    ,					A			:							Dict=3    ,					A			:							Dict=[3, 3, 5]    ,					A			:							Optional[int]=[32, 16, 24]    ,					A			:							Union[str, Any]=[16, 24, 40]    ,					A			:							Optional[int]=[1, 1, 2]    ,					A			:							Tuple=[1, 1, 2]    ,					A			:							List[Any]=[1, 6, 6]    ,					A			:							List[Any]=True    ,					A			:							Optional[int]=True    ,					A			:							Dict=37    ,					A			:							Union[str, Any]="gelu"    ,					A			:							Tuple=10    ,					)      ->      List[str]:






         """simple docstring"""
         a__  			=							parent
         a__  			=							batch_size
         a__  			=							image_size
         a__  			=							num_channels
         a__  			=							kernel_sizes
         a__  			=							in_channels
         a__  			=							out_channels
         a__  			=							strides
         a__  			=							num_block_repeats
         a__  			=							expand_ratios
         a__  			=							is_training
         a__  			=							hidden_act
         a__  			=							num_labels
         a__  			=							use_labels

     def 					__SCREAMING_SNAKE_CASE		(   self			:							List[str]     )      ->      str:






         """simple docstring"""
         a__  			=							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

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

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

     def 					__SCREAMING_SNAKE_CASE		(   self			:							List[Any]     )      ->      List[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 					__SCREAMING_SNAKE_CASE		(   self			:							int    ,					A			:							Optional[int]    ,					A			:							Any    ,					A			:							Any     )      ->      Optional[int]:






         """simple docstring"""
         a__  			=							EfficientNetModel(config=_lowercase     )
         model.to(_lowercase     )
         model.eval()
         a__  			=							model(_lowercase     )
         # 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 					__SCREAMING_SNAKE_CASE		(   self			:							int    ,					A			:							Optional[int]    ,					A			:							List[str]    ,					A			:							Dict     )      ->      Optional[int]:






         """simple docstring"""
         a__  			=							EfficientNetForImageClassification(_lowercase     )
         model.to(_lowercase     )
         model.eval()
         a__  			=							model(_lowercase    ,					labels=_lowercase     )
         self.parent.assertEqual(result.logits.shape    ,					(self.batch_size, self.num_labels)     )






     def 					__SCREAMING_SNAKE_CASE		(   self			:							List[Any]     )      ->      int:






         """simple docstring"""
         a__  			=							self.prepare_config_and_inputs()
         a__			,		a__			,		a__  			=							config_and_inputs
         a__  			=							{"""pixel_values""": pixel_values}
         return config, inputs_dict







@require_torch
class 		__UpperCAmelCase(		lowerCAmelCase__							,						lowerCAmelCase__							,						unittest.TestCase			):





     """simple docstring"""



     __UpperCAmelCase						:			str							=     (EfficientNetModel, EfficientNetForImageClassification) if is_torch_available() else ()
     __UpperCAmelCase						:			int							=     (
         {"""feature-extraction""": EfficientNetModel, """image-classification""": EfficientNetForImageClassification}
         if is_torch_available()
         else {}
     )

     __UpperCAmelCase						:			str							=     False
     __UpperCAmelCase						:			int							=     False
     __UpperCAmelCase						:			int							=     False
     __UpperCAmelCase						:			List[Any]							=     False
     __UpperCAmelCase						:			int							=     False

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






         """simple docstring"""
         a__  			=							EfficientNetModelTester(self     )
         a__  			=							ConfigTester(
             self    ,					config_class=_lowercase    ,					has_text_modality=_lowercase    ,					hidden_size=37     )

     def 					__SCREAMING_SNAKE_CASE		(   self			:							Any     )      ->      Tuple:






         """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 					__SCREAMING_SNAKE_CASE		(   self			:							Optional[Any]     )      ->      Union[str, Any]:






         """simple docstring"""
         return

     @unittest.skip(reason="""EfficientNet does not use inputs_embeds"""     )
     def 					__SCREAMING_SNAKE_CASE		(   self			:							int     )      ->      Optional[Any]:






         """simple docstring"""
         pass

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






         """simple docstring"""
         pass

     @unittest.skip(reason="""EfficientNet does not use feedforward chunking"""     )
     def 					__SCREAMING_SNAKE_CASE		(   self			:							Optional[int]     )      ->      List[Any]:






         """simple docstring"""
         pass

     def 					__SCREAMING_SNAKE_CASE		(   self			:							Optional[Any]     )      ->      List[Any]:






         """simple docstring"""
         a__			,		a__  			=							self.model_tester.prepare_config_and_inputs_for_common()

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

             a__  			=							["""pixel_values"""]
             self.assertListEqual(arg_names[:1]    ,					_lowercase     )

     def 					__SCREAMING_SNAKE_CASE		(   self			:							str     )      ->      Tuple:






         """simple docstring"""
         a__  			=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*_lowercase     )

     def 					__SCREAMING_SNAKE_CASE		(   self			:							List[str]     )      ->      Dict:






         """simple docstring"""


         def check_hidden_states_output(A			:							Dict    ,					A			:							str    ,					A			:							Optional[int]     ):
             a__  			=							model_class(_lowercase     )
             model.to(_lowercase     )
             model.eval()

             with torch.no_grad():
                 a__  			=							model(**self._prepare_for_class(_lowercase    ,					_lowercase     )     )

             a__  			=							outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
             a__  			=							sum(config.num_block_repeats     ) * 4
             self.assertEqual(len(_lowercase     )    ,					_lowercase     )

             # 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__  			=							self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
             a__  			=							True
             check_hidden_states_output(_lowercase    ,					_lowercase    ,					_lowercase     )

             # check that output_hidden_states also work using config
             del inputs_dict["output_hidden_states"]
             a__  			=							True

             check_hidden_states_output(_lowercase    ,					_lowercase    ,					_lowercase     )

     def 					__SCREAMING_SNAKE_CASE		(   self			:							Tuple     )      ->      List[Any]:






         """simple docstring"""
         a__  			=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*_lowercase     )

     @unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""     )
     def 					__SCREAMING_SNAKE_CASE		(   self			:							List[str]     )      ->      Tuple:






         """simple docstring"""
         pass

     @slow
     def 					__SCREAMING_SNAKE_CASE		(   self			:							Optional[int]     )      ->      List[Any]:






         """simple docstring"""


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






     @is_pipeline_test
     @require_vision
     @slow
     def 					__SCREAMING_SNAKE_CASE		(   self			:							int     )      ->      List[str]:






         """simple docstring"""
         super().test_pipeline_image_classification()






def 							__lowerCAmelCase			():
    a__  			=							Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""		)
    return image







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





     """simple docstring"""



     @cached_property
     def 					__SCREAMING_SNAKE_CASE		(   self			:							Any     )      ->      int:






         """simple docstring"""
         return AutoImageProcessor.from_pretrained("""google/efficientnet-b7"""     ) if is_vision_available() else None






     @slow
     def 					__SCREAMING_SNAKE_CASE		(   self			:							List[Any]     )      ->      Tuple:






         """simple docstring"""
         a__  			=							EfficientNetForImageClassification.from_pretrained("""google/efficientnet-b7"""     ).to(_lowercase     )

         a__  			=							self.default_image_processor
         a__  			=							prepare_img()
         a__  			=							image_processor(images=_lowercase    ,					return_tensors="""pt"""     ).to(_lowercase     )

         # forward pass
         with torch.no_grad():
             a__  			=							model(**_lowercase     )

         # verify the logits
         a__  			=							torch.Size((1, 10_00)     )
         self.assertEqual(outputs.logits.shape    ,					_lowercase     )

         a__  			=							torch.tensor([0.0_0_0_1, 0.0_0_0_2, 0.0_0_0_2]     ).to(_lowercase     )
         self.assertTrue(torch.allclose(outputs.logits[0, :3]    ,					_lowercase    ,					atol=1E-4     )     )












from hashlib import mda, shaaaa

__A						:		Optional[int]          =						(shaaaa, mda)

class 		lowercase_       :




					def __init__(   self:		str,     _lowercase:		int = 8):


									'''simple docstring'''


									__lowerCAmelCase					=  0b0
									__lowerCAmelCase					=  size




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


									'''simple docstring'''


									__lowerCAmelCase					=  self.hash_(_lowercase)
									self.bitarray |= h




					def     _lowercase						(   self:		Dict,     _lowercase:		str):


									'''simple docstring'''


									__lowerCAmelCase					=  self.hash_(_lowercase)
									return (h & self.bitarray) == h




					def __contains__(   self:		Dict,     _lowercase:		str):


									'''simple docstring'''


									return self.exists(_lowercase)




					def     _lowercase						(   self:		List[Any],     _lowercase:		int):


									'''simple docstring'''


									__lowerCAmelCase					=  bin(_lowercase)[2:]
									return res.zfill(self.size)




					@property
					def     _lowercase						(   self:		Union[str, Any]):


									'''simple docstring'''


									return self.format_bin(self.bitarray)




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


									'''simple docstring'''


									__lowerCAmelCase					=  0b0
									for func in HASH_FUNCTIONS:
													__lowerCAmelCase					=  (
													    int.from_bytes(func(value.encode()).digest(),     """little""") % self.size
													)
													res |= 2**position
									return res




					def     _lowercase						(   self:		Any,     _lowercase:		str):


									'''simple docstring'''


									return self.format_bin(self.hash_(_lowercase))







					@property
					def     _lowercase						(   self:		Tuple):


									'''simple docstring'''


									__lowerCAmelCase					=  bin(self.bitarray).count("""1""")
									return (n_ones / self.size) ** len(_lowercase)





