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

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

										lowercase   :    Union[str, Any]			=							self.get_config()
										return config, pixel_values, labels
			def       __magic_name__      (      self    ):
										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       __magic_name__      (      self     ,   _a     ,   _a     ,   _a    ):
										lowercase   :    Tuple			=							EfficientNetModel(config=snake_case_    )
										model.to(snake_case_    )
										model.eval()
										lowercase   :    str			=							model(snake_case_    )
										# 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       __magic_name__      (      self     ,   _a     ,   _a     ,   _a    ):
										lowercase   :    Optional[int]			=							EfficientNetForImageClassification(snake_case_    )
										model.to(snake_case_    )
										model.eval()
										lowercase   :    int			=							model(snake_case_     ,   labels=snake_case_    )
										self.parent.assertEqual(result.logits.shape     ,   (self.batch_size, self.num_labels)    )

			def       __magic_name__      (      self    ):
										lowercase   :    Optional[Any]			=							self.prepare_config_and_inputs()
										lowercase   :    Tuple			=							config_and_inputs
										lowercase   :    Any			=							{"""pixel_values""": pixel_values}
										return config, inputs_dict


@require_torch
class 		a__						(				_a,      _a,      unittest.TestCase						):
			__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       __magic_name__      (      self    ):
										lowercase   :    Dict			=							EfficientNetModelTester(self    )
										lowercase   :    Any			=							ConfigTester(
										    self     ,   config_class=snake_case_     ,   has_text_modality=snake_case_     ,   hidden_size=37    )
			def       __magic_name__      (      self    ):
										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       __magic_name__      (      self    ):
										return
			@unittest.skip(reason="EfficientNet does not use inputs_embeds"    )
			def       __magic_name__      (      self    ):
										pass
			@unittest.skip(reason="EfficientNet does not support input and output embeddings"    )
			def       __magic_name__      (      self    ):
										pass
			@unittest.skip(reason="EfficientNet does not use feedforward chunking"    )
			def       __magic_name__      (      self    ):
										pass
			def       __magic_name__      (      self    ):
										lowercase   :    Dict			=							self.model_tester.prepare_config_and_inputs_for_common()

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

																	lowercase   :    str			=							["""pixel_values"""]
																	self.assertListEqual(arg_names[:1]     ,   snake_case_    )
			def       __magic_name__      (      self    ):
										lowercase   :    List[str]			=							self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*snake_case_    )
			def       __magic_name__      (      self    ):
										def check_hidden_states_output(_a     ,   _a     ,   _a    ):
																	lowercase   :    Optional[int]			=							model_class(snake_case_    )
																	model.to(snake_case_    )
																	model.eval()

																	with torch.no_grad():
																								lowercase   :    Optional[Any]			=							model(**self._prepare_for_class(snake_case_     ,   snake_case_    )    )

																	lowercase   :    Dict			=							outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
																	lowercase   :    Union[str, Any]			=							sum(config.num_block_repeats    ) * 4
																	self.assertEqual(len(snake_case_    )     ,   snake_case_    )

																	# 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]     ,   )

										lowercase   :    Union[str, Any]			=							self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
																	lowercase   :    Dict			=							True
																	check_hidden_states_output(snake_case_     ,   snake_case_     ,   snake_case_    )

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

																	check_hidden_states_output(snake_case_     ,   snake_case_     ,   snake_case_    )
			def       __magic_name__      (      self    ):
										lowercase   :    Optional[Any]			=							self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*snake_case_    )
			@unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."    )
			def       __magic_name__      (      self    ):
										pass
			@slow
			def       __magic_name__      (      self    ):
										for model_name in EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	lowercase   :    int			=							EfficientNetModel.from_pretrained(snake_case_    )
																	self.assertIsNotNone(snake_case_    )

			@is_pipeline_test
			@require_vision
			@slow
			def       __magic_name__      (      self    ):
										super().test_pipeline_image_classification()


def   __magic_name__     (				)			->    Union[str, Any]:
							lowercase   :    Dict			=							Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"  )
							return image

@require_torch
@require_vision
class 		a__						(				unittest.TestCase						):
			@cached_property
			def       __magic_name__      (      self    ):
										return AutoImageProcessor.from_pretrained("google/efficientnet-b7"    ) if is_vision_available() else None

			@slow
			def       __magic_name__      (      self    ):
										lowercase   :    Tuple			=							EfficientNetForImageClassification.from_pretrained("google/efficientnet-b7"    ).to(snake_case_    )

										lowercase   :    int			=							self.default_image_processor
										lowercase   :    Optional[Any]			=							prepare_img()
										lowercase   :    List[str]			=							image_processor(images=snake_case_     ,   return_tensors="pt"    ).to(snake_case_    )

										# forward pass
										with torch.no_grad():
																	lowercase   :    Optional[int]			=							model(**snake_case_    )

										# verify the logits
										lowercase   :    Dict			=							torch.Size((1, 1_000)    )
										self.assertEqual(outputs.logits.shape     ,   snake_case_    )

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




"""simple docstring"""




import warnings

from ...utils import logging
from .image_processing_convnext import ConvNextImageProcessor


_A      :	List[str]       		=	logging.get_logger(__name__)

class 		a__						(				a_						):
   def __init__(      self     ,   *_a     ,   **_a    ):
          warnings.warn(
              "The class ConvNextFeatureExtractor is deprecated and will be removed in version 5 of Transformers."
              " Please use ConvNextImageProcessor instead."     ,   _a     ,   )
          super().__init__(*_a     ,   **_a    )


