
"""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 	lowerCamelCase__      :





			'''simple docstring'''



			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  ,  )				->  Any:
				_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       _lowerCAmelCase	(							self						)				->  Optional[Any]:
				_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       _lowerCAmelCase	(							self						)				->  Union[str, Any]:
				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       _lowerCAmelCase	(							self  ,  __UpperCAmelCase  ,  __UpperCAmelCase  ,  __UpperCAmelCase						)				->  Optional[Any]:
				_lowerCAmelCase			=EfficientNetModel(config=__UpperCAmelCase						)
				model.to(__UpperCAmelCase						)
				model.eval()
				_lowerCAmelCase			=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       _lowerCAmelCase	(							self  ,  __UpperCAmelCase  ,  __UpperCAmelCase  ,  __UpperCAmelCase						)				->  Optional[int]:
				_lowerCAmelCase			=EfficientNetForImageClassification(__UpperCAmelCase						)
				model.to(__UpperCAmelCase						)
				model.eval()
				_lowerCAmelCase			=model(__UpperCAmelCase  ,  labels=__UpperCAmelCase						)
				self.parent.assertEqual(result.logits.shape  ,  (self.batch_size, self.num_labels)						)



			def       _lowerCAmelCase	(							self						)				->  Optional[Any]:
				_lowerCAmelCase			=self.prepare_config_and_inputs()
				_lowerCAmelCase		,							_lowerCAmelCase		,							_lowerCAmelCase			=config_and_inputs
				_lowerCAmelCase			={"""pixel_values""": pixel_values}
				return config, inputs_dict







@require_torch
class 	lowerCamelCase__      (      __magic_name__				,			__magic_name__				,			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       _lowerCAmelCase	(							self						)				->  Dict:
				_lowerCAmelCase			=EfficientNetModelTester(self						)
				_lowerCAmelCase			=ConfigTester(
				    self  ,  config_class=__UpperCAmelCase  ,  has_text_modality=__UpperCAmelCase  ,  hidden_size=37						)



			def       _lowerCAmelCase	(							self						)				->  int:
				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       _lowerCAmelCase	(							self						)				->  List[str]:
				return



			@unittest.skip(reason="""EfficientNet does not use inputs_embeds"""						)
			def       _lowerCAmelCase	(							self						)				->  List[Any]:
				pass



			@unittest.skip(reason="""EfficientNet does not support input and output embeddings"""						)
			def       _lowerCAmelCase	(							self						)				->  Dict:
				pass



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



			def       _lowerCAmelCase	(							self						)				->  Any:
				_lowerCAmelCase		,							_lowerCAmelCase			=self.model_tester.prepare_config_and_inputs_for_common()

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



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



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

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

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

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

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

					check_hidden_states_output(__UpperCAmelCase  ,  __UpperCAmelCase  ,  __UpperCAmelCase						)



			def       _lowerCAmelCase	(							self						)				->  Union[str, Any]:
				_lowerCAmelCase			=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       _lowerCAmelCase	(							self						)				->  Any:
				pass



			@slow
			def       _lowerCAmelCase	(							self						)				->  Tuple:
				for model_name in EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					_lowerCAmelCase			=EfficientNetModel.from_pretrained(__UpperCAmelCase						)
					self.assertIsNotNone(__UpperCAmelCase						)



			@is_pipeline_test
			@require_vision
			@slow
			def       _lowerCAmelCase	(							self						)				->  Union[str, Any]:
				super().test_pipeline_image_classification()







def 					_lowerCamelCase()       ->				int:
	_lowerCAmelCase			=Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png""" )
	return image







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





			'''simple docstring'''



			@cached_property
			def       _lowerCAmelCase	(							self						)				->  Optional[Any]:
				return AutoImageProcessor.from_pretrained("""google/efficientnet-b7"""						) if is_vision_available() else None



			@slow
			def       _lowerCAmelCase	(							self						)				->  List[str]:
				_lowerCAmelCase			=EfficientNetForImageClassification.from_pretrained("""google/efficientnet-b7"""						).to(__UpperCAmelCase						)

				_lowerCAmelCase			=self.default_image_processor
				_lowerCAmelCase			=prepare_img()
				_lowerCAmelCase			=image_processor(images=__UpperCAmelCase  ,  return_tensors="""pt"""						).to(__UpperCAmelCase						)

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

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

				_lowerCAmelCase			=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 					_lowerCamelCase(__UpperCamelCase					,				__UpperCamelCase					,				__UpperCamelCase )       ->				float:
	if mass < 0:
		raise ValueError("""The mass of the body cannot be negative""" )
	if radius <= 0:
		raise ValueError("""The radius is always a positive non zero integer""" )
	return (mass * (velocity) ** 2) / radius


if __name__ == "__main__":
			import doctest

			doctest.testmod(verbose=True)



