
'''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 			UpperCamelCase__	:






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







       '''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 						lowercase_    (      self	:Optional[Any]      )					->      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 						lowercase_    (      self	:int						,					_A	:Union[str, Any]						,					_A	:List[str]						,					_A	:Union[str, Any]      )					->      Optional[Any]:







       '''simple docstring'''



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







       '''simple docstring'''



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






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







       '''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__	(     SCREAMING_SNAKE_CASE   ,  SCREAMING_SNAKE_CASE   ,  unittest.TestCase):
 UpperCAmelCase__     :     Optional[Any]    					=       (EfficientNetModel, EfficientNetForImageClassification) if is_torch_available() else ()
 UpperCAmelCase__     :     Optional[int]    					=       (
     {'feature-extraction': EfficientNetModel, 'image-classification': EfficientNetForImageClassification}
     if is_torch_available()
     else {}
 )

 UpperCAmelCase__     :     Tuple    					=       False
 UpperCAmelCase__     :     Optional[int]    					=       False
 UpperCAmelCase__     :     str    					=       False
 UpperCAmelCase__     :     List[Any]    					=       False
 UpperCAmelCase__     :     Any    					=       False






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







       '''simple docstring'''



       __A													=      EfficientNetModelTester(self      )
       __A													=      ConfigTester(
           self						,					config_class=_A						,					has_text_modality=_A						,					hidden_size=37      )






 def 						lowercase_    (      self	:Optional[int]      )					->      Dict:







       '''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 						lowercase_    (      self	:Optional[Any]      )					->      List[str]:







       '''simple docstring'''



       return






 @unittest.skip(reason='EfficientNet does not use inputs_embeds'      )
 def 						lowercase_    (      self	:List[str]      )					->      Union[str, Any]:







       '''simple docstring'''



       pass






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







       '''simple docstring'''



       pass






 @unittest.skip(reason='EfficientNet does not use feedforward chunking'      )
 def 						lowercase_    (      self	:Union[str, Any]      )					->      Union[str, Any]:







       '''simple docstring'''



       pass






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







       '''simple docstring'''



       __A						,   __A													=      self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
             __A													=      model_class(_A      )
             __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]						,					_A      )






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







       '''simple docstring'''



       __A													=      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_A      )






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







       '''simple docstring'''



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

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

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

       __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(_A						,					_A						,					_A      )

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

             check_hidden_states_output(_A						,					_A						,					_A      )






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







       '''simple docstring'''



       __A													=      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 						lowercase_    (      self	:Optional[Any]      )					->      str:







       '''simple docstring'''



       pass






 @slow
 def 						lowercase_    (      self	:List[str]      )					->      Optional[int]:







       '''simple docstring'''



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






 @is_pipeline_test
 @require_vision
 @slow
 def 						lowercase_    (      self	:List[Any]      )					->      Any:







       '''simple docstring'''



       super().test_pipeline_image_classification()





def 							snake_case				(		)->      List[Any]:







      """simple docstring"""
      __A													=      Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'						)
      return image


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






 @cached_property
 def 						lowercase_    (      self	:Dict      )					->      Dict:







       '''simple docstring'''



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






 @slow
 def 						lowercase_    (      self	:Tuple      )					->      int:







       '''simple docstring'''



       __A													=      EfficientNetForImageClassification.from_pretrained('google/efficientnet-b7'      ).to(_A      )

       __A													=      self.default_image_processor
       __A													=      prepare_img()
       __A													=      image_processor(images=_A						,					return_tensors='pt'      ).to(_A      )

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

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

       __A													=      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"""


from ...configuration_utils import PretrainedConfig
from ...utils import logging


__A					=			logging.get_logger(__name__)

__A					=			{
    'uw-madison/nystromformer-512': 'https://huggingface.co/uw-madison/nystromformer-512/resolve/main/config.json',
    # See all Nystromformer models at https://huggingface.co/models?filter=nystromformer
}







class 						lowerCamelCase__   (   __magic_name__							):





			'''simple docstring'''
			lowerCamelCase       =						'''nystromformer'''



			def __init__(				self	,	__UpperCAmelCase=3_00_00	,	__UpperCAmelCase=7_68	,	__UpperCAmelCase=12	,	__UpperCAmelCase=12	,	__UpperCAmelCase=30_72	,	__UpperCAmelCase="gelu_new"	,	__UpperCAmelCase=0.1	,	__UpperCAmelCase=0.1	,	__UpperCAmelCase=5_10	,	__UpperCAmelCase=2	,	__UpperCAmelCase=64	,	__UpperCAmelCase=64	,	__UpperCAmelCase=65	,	__UpperCAmelCase=False	,	__UpperCAmelCase=0.0_2	,	__UpperCAmelCase=1e-5	,	__UpperCAmelCase=1	,	__UpperCAmelCase=0	,	__UpperCAmelCase=2	,	**__UpperCAmelCase	,	)					->	Union[str, Any]:
				_lowerCAmelCase								=vocab_size
				_lowerCAmelCase								=max_position_embeddings
				_lowerCAmelCase								=hidden_size
				_lowerCAmelCase								=num_hidden_layers
				_lowerCAmelCase								=num_attention_heads
				_lowerCAmelCase								=intermediate_size
				_lowerCAmelCase								=hidden_act
				_lowerCAmelCase								=hidden_dropout_prob
				_lowerCAmelCase								=attention_probs_dropout_prob
				_lowerCAmelCase								=initializer_range
				_lowerCAmelCase								=type_vocab_size
				_lowerCAmelCase								=segment_means_seq_len
				_lowerCAmelCase								=num_landmarks
				_lowerCAmelCase								=conv_kernel_size
				_lowerCAmelCase								=inv_coeff_init_option
				_lowerCAmelCase								=layer_norm_eps
				super().__init__(pad_token_id=__UpperCAmelCase	,	bos_token_id=__UpperCAmelCase	,	eos_token_id=__UpperCAmelCase	,	**__UpperCAmelCase    )



