
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		:			str	,						_lowerCamelCase		:			str	,						_lowerCamelCase		:			int=13	,						_lowerCamelCase		:			Any=32	,						_lowerCamelCase		:			Tuple=3	,						_lowerCamelCase		:			Optional[Any]=[3, 3, 5]	,						_lowerCamelCase		:			Optional[Any]=[32, 16, 24]	,						_lowerCamelCase		:			Any=[16, 24, 40]	,						_lowerCamelCase		:			Optional[Any]=[1, 1, 2]	,						_lowerCamelCase		:			Union[str, Any]=[1, 1, 2]	,						_lowerCamelCase		:			Dict=[1, 6, 6]	,						_lowerCamelCase		:			str=True	,						_lowerCamelCase		:			Optional[Any]=True	,						_lowerCamelCase		:			Optional[Any]=37	,						_lowerCamelCase		:			Tuple="gelu"	,						_lowerCamelCase		:			Any=10	,						):
													_UpperCAmelCase  :			List[Any]	       =		parent
													_UpperCAmelCase  :			Union[str, Any]	       =		batch_size
													_UpperCAmelCase  :			Optional[int]	       =		image_size
													_UpperCAmelCase  :			Optional[int]	       =		num_channels
													_UpperCAmelCase  :			str	       =		kernel_sizes
													_UpperCAmelCase  :			List[Any]	       =		in_channels
													_UpperCAmelCase  :			List[Any]	       =		out_channels
													_UpperCAmelCase  :			str	       =		strides
													_UpperCAmelCase  :			Any	       =		num_block_repeats
													_UpperCAmelCase  :			Any	       =		expand_ratios
													_UpperCAmelCase  :			Any	       =		is_training
													_UpperCAmelCase  :			Optional[Any]	       =		hidden_act
													_UpperCAmelCase  :			Optional[Any]	       =		num_labels
													_UpperCAmelCase  :			List[str]	       =		use_labels

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

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

													_UpperCAmelCase  :			Tuple	       =		self.get_config()
													return config, pixel_values, labels

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






						def 						a__ (					self		:			str			):
													_UpperCAmelCase  :			Union[str, Any]	       =		self.prepare_config_and_inputs()
													_UpperCAmelCase       ,_UpperCAmelCase       ,_UpperCAmelCase  :			str	       =		config_and_inputs
													_UpperCAmelCase  :			List[str]	       =		{"pixel_values": pixel_values}
													return config, inputs_dict







@require_torch
class    _UpperCamelCase(   SCREAMING_SNAKE_CASE		,						SCREAMING_SNAKE_CASE		,						unittest.TestCase				):
						__A:						Dict				   =      (EfficientNetModel, EfficientNetForImageClassification) if is_torch_available() else ()
						__A:						Optional[Any]				   =      (
						    {"""feature-extraction""": EfficientNetModel, """image-classification""": EfficientNetForImageClassification}
						    if is_torch_available()
						    else {}
						)

						__A:						Optional[Any]				   =      False
						__A:						int				   =      False
						__A:						Union[str, Any]				   =      False
						__A:						List[Any]				   =      False
						__A:						Any				   =      False

						def 						a__ (					self		:			Optional[int]			):
													_UpperCAmelCase  :			Optional[Any]	       =		EfficientNetModelTester(self			)
													_UpperCAmelCase  :			List[Any]	       =		ConfigTester(
													    self	,						config_class=_lowerCamelCase	,						has_text_modality=_lowerCamelCase	,						hidden_size=37			)

						def 						a__ (					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 						a__ (					self		:			Any			):
													return

						@unittest.skip(reason="EfficientNet does not use inputs_embeds"			)
						def 						a__ (					self		:			int			):
													pass

						@unittest.skip(reason="EfficientNet does not support input and output embeddings"			)
						def 						a__ (					self		:			Optional[int]			):
													pass

						@unittest.skip(reason="EfficientNet does not use feedforward chunking"			)
						def 						a__ (					self		:			Optional[Any]			):
													pass

						def 						a__ (					self		:			Tuple			):
													_UpperCAmelCase       ,_UpperCAmelCase  :			int	       =		self.model_tester.prepare_config_and_inputs_for_common()

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

																				_UpperCAmelCase  :			Optional[Any]	       =		["pixel_values"]
																				self.assertListEqual(arg_names[:1]	,						_lowerCamelCase			)

						def 						a__ (					self		:			Optional[int]			):
													_UpperCAmelCase  :			str	       =		self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(*_lowerCamelCase			)

						def 						a__ (					self		:			int			):
													def check_hidden_states_output(_lowerCamelCase		:			Union[str, Any]	,						_lowerCamelCase		:			Dict	,						_lowerCamelCase		:			Dict			):
																				_UpperCAmelCase  :			Any	       =		model_class(_lowerCamelCase			)
																				model.to(_lowerCamelCase			)
																				model.eval()

																				with torch.no_grad():
																											_UpperCAmelCase  :			List[str]	       =		model(**self._prepare_for_class(_lowerCamelCase	,						_lowerCamelCase			)			)

																				_UpperCAmelCase  :			int	       =		outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
																				_UpperCAmelCase  :			Optional[Any]	       =		sum(config.num_block_repeats			) * 4
																				self.assertEqual(len(_lowerCamelCase			)	,						_lowerCamelCase			)

																				# 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  :			int	       =		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(_lowerCamelCase	,						_lowerCamelCase	,						_lowerCamelCase			)

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

																				check_hidden_states_output(_lowerCamelCase	,						_lowerCamelCase	,						_lowerCamelCase			)

						def 						a__ (					self		:			Union[str, Any]			):
													_UpperCAmelCase  :			List[str]	       =		self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_image_classification(*_lowerCamelCase			)

						@unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."			)
						def 						a__ (					self		:			Optional[int]			):
													pass

						@slow
						def 						a__ (					self		:			Union[str, Any]			):
													for model_name in EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																				_UpperCAmelCase  :			Any	       =		EfficientNetModel.from_pretrained(_lowerCamelCase			)
																				self.assertIsNotNone(_lowerCamelCase			)






						@is_pipeline_test
						@require_vision
						@slow
						def 						a__ (					self		:			List[str]			):
													super().test_pipeline_image_classification()







def 		lowerCAmelCase_     (     )   ->      Optional[int]:

							"""simple docstring"""






							_UpperCAmelCase  :			Union[str, Any]	       =		Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"  )
							return image


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

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






						@slow
						def 						a__ (					self		:			Optional[int]			):
													_UpperCAmelCase  :			Optional[Any]	       =		EfficientNetForImageClassification.from_pretrained("google/efficientnet-b7"			).to(_lowerCamelCase			)

													_UpperCAmelCase  :			str	       =		self.default_image_processor
													_UpperCAmelCase  :			Any	       =		prepare_img()
													_UpperCAmelCase  :			Any	       =		image_processor(images=_lowerCamelCase	,						return_tensors="pt"			).to(_lowerCamelCase			)

													# forward pass
													with torch.no_grad():
																				_UpperCAmelCase  :			List[str]	       =		model(**_lowerCamelCase			)

													# verify the logits
													_UpperCAmelCase  :			List[Any]	       =		torch.Size((1, 10_00)			)
													self.assertEqual(outputs.logits.shape	,						_lowerCamelCase			)

													_UpperCAmelCase  :			int	       =		torch.tensor([0.00_01, 0.00_02, 0.00_02]			).to(_lowerCamelCase			)
													self.assertTrue(torch.allclose(outputs.logits[0, :3]	,						_lowerCamelCase	,						atol=1E-4			)			)






from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import center_crop, normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
				import PIL


__lowerCamelCase								=					logging.get_logger(__name__)
class    _UpperCamelCase(   SCREAMING_SNAKE_CASE				):
						__A:						Union[str, Any]				   =      ["""pixel_values"""]

						def __init__(					self		:			str	,						_lowerCamelCase		:			bool = True	,						_lowerCamelCase		:			Dict[str, int] = None	,						_lowerCamelCase		:			PILImageResampling = PIL.Image.NEAREST	,						_lowerCamelCase		:			bool = False	,						_lowerCamelCase		:			Dict[str, int] = None	,						_lowerCamelCase		:			Union[int, float] = 1 / 2_55	,						_lowerCamelCase		:			bool = False	,						_lowerCamelCase		:			bool = True	,						_lowerCamelCase		:			bool = True	,						_lowerCamelCase		:			Optional[Union[float, List[float]]] = None	,						_lowerCamelCase		:			Optional[Union[float, List[float]]] = None	,						_lowerCamelCase		:			bool = True	,						**_lowerCamelCase		:			Tuple	,						):
													super().__init__(**_lowerCamelCase			)
													_UpperCAmelCase  :			int	       =		size if size is not None else {"height": 3_46, "width": 3_46}
													_UpperCAmelCase  :			Dict	       =		get_size_dict(_lowerCamelCase			)
													_UpperCAmelCase  :			List[str]	       =		crop_size if crop_size is not None else {"height": 2_89, "width": 2_89}
													_UpperCAmelCase  :			int	       =		get_size_dict(_lowerCamelCase	,						param_name="crop_size"			)

													_UpperCAmelCase  :			Dict	       =		do_resize
													_UpperCAmelCase  :			Tuple	       =		size
													_UpperCAmelCase  :			Union[str, Any]	       =		resample
													_UpperCAmelCase  :			List[Any]	       =		do_center_crop
													_UpperCAmelCase  :			List[str]	       =		crop_size
													_UpperCAmelCase  :			int	       =		do_rescale
													_UpperCAmelCase  :			str	       =		rescale_factor
													_UpperCAmelCase  :			int	       =		rescale_offset
													_UpperCAmelCase  :			Any	       =		do_normalize
													_UpperCAmelCase  :			Optional[int]	       =		image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
													_UpperCAmelCase  :			List[str]	       =		image_std if image_std is not None else IMAGENET_STANDARD_STD
													_UpperCAmelCase  :			Dict	       =		include_top

						def 						a__ (					self		:			Optional[Any]	,						_lowerCamelCase		:			np.ndarray	,						_lowerCamelCase		:			Dict[str, int]	,						_lowerCamelCase		:			PILImageResampling = PIL.Image.NEAREST	,						_lowerCamelCase		:			Optional[Union[str, ChannelDimension]] = None	,						**_lowerCamelCase		:			Tuple	,						):
													_UpperCAmelCase  :			Optional[int]	       =		get_size_dict(_lowerCamelCase			)
													if "height" not in size or "width" not in size:
																				raise ValueError(f"""The size dictionary must have keys 'height' and 'width'. Got {size.keys()}"""			)
													return resize(
													    _lowerCamelCase	,						size=(size["height"], size["width"])	,						resample=_lowerCamelCase	,						data_format=_lowerCamelCase	,						**_lowerCamelCase			)

						def 						a__ (					self		:			Optional[Any]	,						_lowerCamelCase		:			np.ndarray	,						_lowerCamelCase		:			Dict[str, int]	,						_lowerCamelCase		:			Optional[Union[str, ChannelDimension]] = None	,						**_lowerCamelCase		:			List[str]	,						):
													_UpperCAmelCase  :			Optional[Any]	       =		get_size_dict(_lowerCamelCase			)
													if "height" not in size or "width" not in size:
																				raise ValueError(f"""The size dictionary must have keys 'height' and 'width'. Got {size.keys()}"""			)
													return center_crop(_lowerCamelCase	,						size=(size["height"], size["width"])	,						data_format=_lowerCamelCase	,						**_lowerCamelCase			)

						def 						a__ (					self		:			Optional[Any]	,						_lowerCamelCase		:			np.ndarray	,						_lowerCamelCase		:			Union[int, float]	,						_lowerCamelCase		:			bool = True	,						_lowerCamelCase		:			Optional[Union[str, ChannelDimension]] = None	,						**_lowerCamelCase		:			Tuple	,						):
													if offset:
																				_UpperCAmelCase  :			Any	       =		(image - 1_27.5) * scale
																				if data_format is not None:
																											_UpperCAmelCase  :			Union[str, Any]	       =		to_channel_dimension_format(_lowerCamelCase	,						_lowerCamelCase			)
																				_UpperCAmelCase  :			Optional[Any]	       =		rescaled_image.astype(np.floataa			)
													else:
																				_UpperCAmelCase  :			List[Any]	       =		rescale(_lowerCamelCase	,						scale=_lowerCamelCase	,						data_format=_lowerCamelCase	,						**_lowerCamelCase			)
													return rescaled_image

						def 						a__ (					self		:			Union[str, Any]	,						_lowerCamelCase		:			np.ndarray	,						_lowerCamelCase		:			Union[float, List[float]]	,						_lowerCamelCase		:			Union[float, List[float]]	,						_lowerCamelCase		:			Optional[Union[str, ChannelDimension]] = None	,						**_lowerCamelCase		:			Union[str, Any]	,						):
													return normalize(_lowerCamelCase	,						mean=_lowerCamelCase	,						std=_lowerCamelCase	,						data_format=_lowerCamelCase	,						**_lowerCamelCase			)






						def 						a__ (					self		:			str	,						_lowerCamelCase		:			ImageInput	,						_lowerCamelCase		:			bool = None	,						_lowerCamelCase		:			Dict[str, int] = None	,						_lowerCamelCase		:			List[Any]=None	,						_lowerCamelCase		:			bool = None	,						_lowerCamelCase		:			Dict[str, int] = None	,						_lowerCamelCase		:			bool = None	,						_lowerCamelCase		:			float = None	,						_lowerCamelCase		:			bool = None	,						_lowerCamelCase		:			bool = None	,						_lowerCamelCase		:			Optional[Union[float, List[float]]] = None	,						_lowerCamelCase		:			Optional[Union[float, List[float]]] = None	,						_lowerCamelCase		:			bool = None	,						_lowerCamelCase		:			Optional[Union[str, TensorType]] = None	,						_lowerCamelCase		:			ChannelDimension = ChannelDimension.FIRST	,						**_lowerCamelCase		:			str	,						):
													_UpperCAmelCase  :			Optional[Any]	       =		do_resize if do_resize is not None else self.do_resize
													_UpperCAmelCase  :			Optional[int]	       =		resample if resample is not None else self.resample
													_UpperCAmelCase  :			Tuple	       =		do_center_crop if do_center_crop is not None else self.do_center_crop
													_UpperCAmelCase  :			str	       =		do_rescale if do_rescale is not None else self.do_rescale
													_UpperCAmelCase  :			str	       =		rescale_factor if rescale_factor is not None else self.rescale_factor
													_UpperCAmelCase  :			Tuple	       =		rescale_offset if rescale_offset is not None else self.rescale_offset
													_UpperCAmelCase  :			str	       =		do_normalize if do_normalize is not None else self.do_normalize
													_UpperCAmelCase  :			Dict	       =		image_mean if image_mean is not None else self.image_mean
													_UpperCAmelCase  :			Tuple	       =		image_std if image_std is not None else self.image_std
													_UpperCAmelCase  :			Tuple	       =		include_top if include_top is not None else self.include_top

													_UpperCAmelCase  :			Optional[int]	       =		size if size is not None else self.size
													_UpperCAmelCase  :			Union[str, Any]	       =		get_size_dict(_lowerCamelCase			)
													_UpperCAmelCase  :			int	       =		crop_size if crop_size is not None else self.crop_size
													_UpperCAmelCase  :			int	       =		get_size_dict(_lowerCamelCase	,						param_name="crop_size"			)

													_UpperCAmelCase  :			Union[str, Any]	       =		make_list_of_images(_lowerCamelCase			)

													if not valid_images(_lowerCamelCase			):
																				raise ValueError(
																				    "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
																				    "torch.Tensor, tf.Tensor or jax.ndarray."			)

													if do_resize and size is None or resample is None:
																				raise ValueError("Size and resample must be specified if do_resize is True."			)

													if do_center_crop and crop_size is None:
																				raise ValueError("Crop size must be specified if do_center_crop is True."			)

													if do_rescale and rescale_factor is None:
																				raise ValueError("Rescale factor must be specified if do_rescale is True."			)

													if do_normalize and (image_mean is None or image_std is None):
																				raise ValueError("Image mean and std must be specified if do_normalize is True."			)

													# All transformations expect numpy arrays.
													_UpperCAmelCase  :			Dict	       =		[to_numpy_array(_lowerCamelCase			) for image in images]

													if do_resize:
																				_UpperCAmelCase  :			Any	       =		[self.resize(image=_lowerCamelCase	,						size=_lowerCamelCase	,						resample=_lowerCamelCase			) for image in images]

													if do_center_crop:
																				_UpperCAmelCase  :			int	       =		[self.center_crop(image=_lowerCamelCase	,						size=_lowerCamelCase			) for image in images]

													if do_rescale:
																				_UpperCAmelCase  :			int	       =		[self.rescale(image=_lowerCamelCase	,						scale=_lowerCamelCase	,						offset=_lowerCamelCase			) for image in images]

													if do_normalize:
																				_UpperCAmelCase  :			str	       =		[self.normalize(image=_lowerCamelCase	,						mean=_lowerCamelCase	,						std=_lowerCamelCase			) for image in images]

													if include_top:
																				_UpperCAmelCase  :			int	       =		[self.normalize(image=_lowerCamelCase	,						mean=[0, 0, 0]	,						std=_lowerCamelCase			) for image in images]

													_UpperCAmelCase  :			str	       =		[to_channel_dimension_format(_lowerCamelCase	,						_lowerCamelCase			) for image in images]

													_UpperCAmelCase  :			Dict	       =		{"pixel_values": images}
													return BatchFeature(data=_lowerCamelCase	,						tensor_type=_lowerCamelCase			)




