"""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		,__UpperCAmelCase		,__UpperCAmelCase=13		,__UpperCAmelCase=32		,__UpperCAmelCase=3		,__UpperCAmelCase=[3, 3, 5]		,__UpperCAmelCase=[32, 16, 24]		,__UpperCAmelCase=[16, 24, 40]		,__UpperCAmelCase=[1, 1, 2]		,__UpperCAmelCase=[1, 1, 2]		,__UpperCAmelCase=[1, 6, 6]		,__UpperCAmelCase=True		,__UpperCAmelCase=True		,__UpperCAmelCase=37		,__UpperCAmelCase="gelu"		,__UpperCAmelCase=10		,)       ->					List[str]:
													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 					snake_case__						(							self  )       ->					Dict:
													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 					snake_case__						(							self  )       ->					Optional[int]:
													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		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase  )       ->					Optional[int]:
													A__						  =				EfficientNetModel(config=__UpperCAmelCase  )
													model.to(__UpperCAmelCase  )
													model.eval()
													A__						  =				model(__UpperCAmelCase  )
													# 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		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase  )       ->					Optional[int]:
													A__						  =				EfficientNetForImageClassification(__UpperCAmelCase  )
													model.to(__UpperCAmelCase  )
													model.eval()
													A__						  =				model(__UpperCAmelCase		,labels=__UpperCAmelCase  )
													self.parent.assertEqual(result.logits.shape		,(self.batch_size, self.num_labels)  )





						def 					snake_case__						(							self  )       ->					Tuple:
													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__(      __A		,    __A		,    unittest.TestCase			):
						lowerCAmelCase__	:    Tuple    				=		(EfficientNetModel, EfficientNetForImageClassification) if is_torch_available() else ()
						lowerCAmelCase__	:    Union[str, Any]    				=		(
						    {'feature-extraction': EfficientNetModel, 'image-classification': EfficientNetForImageClassification}
						    if is_torch_available()
						    else {}
						)

						lowerCAmelCase__	:    Optional[Any]    				=		False
						lowerCAmelCase__	:    Tuple    				=		False
						lowerCAmelCase__	:    Dict    				=		False
						lowerCAmelCase__	:    Optional[int]    				=		False
						lowerCAmelCase__	:    Union[str, Any]    				=		False





						def 					snake_case__						(							self  )       ->					Tuple:
													A__						  =				EfficientNetModelTester(self  )
													A__						  =				ConfigTester(
													    self		,config_class=__UpperCAmelCase		,has_text_modality=__UpperCAmelCase		,hidden_size=37  )





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





						@unittest.skip(reason='EfficientNet does not use inputs_embeds'  )
						def 					snake_case__						(							self  )       ->					Optional[Any]:
													pass





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





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





						def 					snake_case__						(							self  )       ->					int:
													A__  ,	A__						  =				self.model_tester.prepare_config_and_inputs_for_common()

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





						def 					snake_case__						(							self  )       ->					Tuple:
													A__						  =				self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(*__UpperCAmelCase  )





						def 					snake_case__						(							self  )       ->					Union[str, Any]:
													def check_hidden_states_output(__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase  ):
																				A__						  =				model_class(__UpperCAmelCase  )
																				model.to(__UpperCAmelCase  )
																				model.eval()

																				with torch.no_grad():
																											A__						  =				model(**self._prepare_for_class(__UpperCAmelCase		,__UpperCAmelCase  )  )

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

																				# 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(__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase  )

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

																				check_hidden_states_output(__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase  )





						def 					snake_case__						(							self  )       ->					int:
													A__						  =				self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_image_classification(*__UpperCAmelCase  )





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





						@slow
						def 					snake_case__						(							self  )       ->					List[str]:
													for model_name in EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																				A__						  =				EfficientNetModel.from_pretrained(__UpperCAmelCase  )
																				self.assertIsNotNone(__UpperCAmelCase  )





						@is_pipeline_test
						@require_vision
						@slow
						def 					snake_case__						(							self  )       ->					int:
													super().test_pipeline_image_classification()






def 	UpperCAmelCase       (						):






							"""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 					snake_case__						(							self  )       ->					int:
													return AutoImageProcessor.from_pretrained('google/efficientnet-b7'  ) if is_vision_available() else None





						@slow
						def 					snake_case__						(							self  )       ->					Optional[int]:
													A__						  =				EfficientNetForImageClassification.from_pretrained('google/efficientnet-b7'  ).to(__UpperCAmelCase  )

													A__						  =				self.default_image_processor
													A__						  =				prepare_img()
													A__						  =				image_processor(images=__UpperCAmelCase		,return_tensors='pt'  ).to(__UpperCAmelCase  )

													# forward pass
													with torch.no_grad():
																				A__						  =				model(**__UpperCAmelCase  )

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

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






"""simple docstring"""




def 	UpperCAmelCase       (						UpperCamelCase__ = 100							,     UpperCamelCase__ = 100					):






							"""simple docstring"""





							return max(
							    sum(int(UpperCamelCase__					) for x in str(base**power					)					)
							    for base in range(UpperCamelCase__					)
							    for power in range(UpperCamelCase__					)					)


# Tests
if __name__ == "__main__":
				import doctest

				doctest.testmod()





