

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							:
   '''simple docstring'''







   def __init__(     self							:	str , a							:	Dict , a							:	Any=13 , a							:	Optional[int]=32 , a							:	str=3 , a							:	Tuple=[3, 3, 5] , a							:	List[Any]=[32, 16, 24] , a							:	Dict=[16, 24, 40] , a							:	List[str]=[1, 1, 2] , a							:	Optional[int]=[1, 1, 2] , a							:	Optional[int]=[1, 6, 6] , a							:	Any=True , a							:	int=True , a							:	int=37 , a							:	str="gelu" , a							:	Optional[int]=10 , )							->    int:

    """simple docstring"""

    SCREAMING_SNAKE_CASE				: Dict			       =    parent
    SCREAMING_SNAKE_CASE				: Any			       =    batch_size
    SCREAMING_SNAKE_CASE				: Union[str, Any]			       =    image_size
    SCREAMING_SNAKE_CASE				: Optional[int]			       =    num_channels
    SCREAMING_SNAKE_CASE				: int			       =    kernel_sizes
    SCREAMING_SNAKE_CASE				: int			       =    in_channels
    SCREAMING_SNAKE_CASE				: List[Any]			       =    out_channels
    SCREAMING_SNAKE_CASE				: int			       =    strides
    SCREAMING_SNAKE_CASE				: str			       =    num_block_repeats
    SCREAMING_SNAKE_CASE				: Tuple			       =    expand_ratios
    SCREAMING_SNAKE_CASE				: Dict			       =    is_training
    SCREAMING_SNAKE_CASE				: Tuple			       =    hidden_act
    SCREAMING_SNAKE_CASE				: Any			       =    num_labels
    SCREAMING_SNAKE_CASE				: str			       =    use_labels
   def 							__UpperCamelCase	(     self							:	str		)							->    str:

    """simple docstring"""

    SCREAMING_SNAKE_CASE				: Dict			       =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

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

    SCREAMING_SNAKE_CASE				: Union[str, Any]			       =    self.get_config()
    return config, pixel_values, labels
   def 							__UpperCamelCase	(     self							:	str		)							->    Dict:

    """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 							__UpperCamelCase	(     self							:	Dict , a							:	Any , a							:	str , a							:	Union[str, Any]		)							->    Optional[Any]:

    """simple docstring"""

    SCREAMING_SNAKE_CASE				: Tuple			       =    EfficientNetModel(config=snake_case_		)
    model.to(snake_case_		)
    model.eval()
    SCREAMING_SNAKE_CASE				: 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 							__UpperCamelCase	(     self							:	Any , a							:	Dict , a							:	Optional[int] , a							:	Optional[int]		)							->    Dict:

    """simple docstring"""

    SCREAMING_SNAKE_CASE				: Optional[int]			       =    EfficientNetForImageClassification(snake_case_		)
    model.to(snake_case_		)
    model.eval()
    SCREAMING_SNAKE_CASE				: int			       =    model(snake_case_ , labels=snake_case_		)
    self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels)		)






   def 							__UpperCamelCase	(     self							:	int		)							->    Dict:

    """simple docstring"""

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






@require_torch
class _UpperCamelCase							(							_a							,		_a							,		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 							__UpperCamelCase	(     self							:	List[Any]		)							->    int:

    """simple docstring"""

    SCREAMING_SNAKE_CASE				: Dict			       =    EfficientNetModelTester(self		)
    SCREAMING_SNAKE_CASE				: Any			       =    ConfigTester(
        self , config_class=snake_case_ , has_text_modality=snake_case_ , hidden_size=37		)
   def 							__UpperCamelCase	(     self							:	Tuple		)							->    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 							__UpperCamelCase	(     self							:	Optional[int]		)							->    Tuple:

    """simple docstring"""

    return
   @unittest.skip(reason="EfficientNet does not use inputs_embeds"		)
   def 							__UpperCamelCase	(     self							:	Dict		)							->    Optional[Any]:

    """simple docstring"""

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

    """simple docstring"""

    pass
   @unittest.skip(reason="EfficientNet does not use feedforward chunking"		)
   def 							__UpperCamelCase	(     self							:	Optional[int]		)							->    Union[str, Any]:

    """simple docstring"""

    pass
   def 							__UpperCamelCase	(     self							:	int		)							->    List[str]:

    """simple docstring"""

    SCREAMING_SNAKE_CASE				: Dict			       =    self.model_tester.prepare_config_and_inputs_for_common()

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

     SCREAMING_SNAKE_CASE				: str			       =    ["""pixel_values"""]
     self.assertListEqual(arg_names[:1] , snake_case_		)
   def 							__UpperCamelCase	(     self							:	int		)							->    List[str]:

    """simple docstring"""

    SCREAMING_SNAKE_CASE				: List[str]			       =    self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model(*snake_case_		)
   def 							__UpperCamelCase	(     self							:	int		)							->    Tuple:

    """simple docstring"""

    def check_hidden_states_output(a							:	str , a							:	Optional[int] , a							:	int		):
     SCREAMING_SNAKE_CASE				: Optional[int]			       =    model_class(snake_case_		)
     model.to(snake_case_		)
     model.eval()

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

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

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

    for model_class in self.all_model_classes:
     SCREAMING_SNAKE_CASE				: 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"]
     SCREAMING_SNAKE_CASE				: Any			       =    True

     check_hidden_states_output(snake_case_ , snake_case_ , snake_case_		)
   def 							__UpperCamelCase	(     self							:	int		)							->    str:

    """simple docstring"""

    SCREAMING_SNAKE_CASE				: 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 							__UpperCamelCase	(     self							:	str		)							->    Tuple:

    """simple docstring"""

    pass
   @slow
   def 							__UpperCamelCase	(     self							:	List[Any]		)							->    Any:

    """simple docstring"""

    for model_name in EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
     SCREAMING_SNAKE_CASE				: int			       =    EfficientNetModel.from_pretrained(snake_case_		)
     self.assertIsNotNone(snake_case_		)






   @is_pipeline_test
   @require_vision
   @slow
   def 							__UpperCamelCase	(     self							:	List[str]		)							->    Optional[int]:

    """simple docstring"""

    super().test_pipeline_image_classification()

def 	lowerCamelCase__	(   ):
 SCREAMING_SNAKE_CASE				: Dict			       =    Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png")
 return image






@require_torch
@require_vision
class _UpperCamelCase							(							unittest.TestCase				):
   '''simple docstring'''







   @cached_property
   def 							__UpperCamelCase	(     self							:	Dict		)							->    int:

    """simple docstring"""

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






   @slow
   def 							__UpperCamelCase	(     self							:	List[Any]		)							->    Dict:

    """simple docstring"""

    SCREAMING_SNAKE_CASE				: Tuple			       =    EfficientNetForImageClassification.from_pretrained("google/efficientnet-b7"		).to(snake_case_		)

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

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

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

    SCREAMING_SNAKE_CASE				: str			       =    torch.tensor([0.0001, 0.0002, 0.0002]		).to(snake_case_		)
    self.assertTrue(torch.allclose(outputs.logits[0, :3] , snake_case_ , atol=1e-4		)		)


from __future__ import annotations

from typing import Any






class _UpperCamelCase							:
			'''simple docstring'''







			def __init__(     self							:	Dict , a							:	Any , a							:	Any		)							->    None:  # noqa: A002

				"""simple docstring"""

				SCREAMING_SNAKE_CASE				: str			       =    item
				SCREAMING_SNAKE_CASE				: List[Any]			       =    next






class _UpperCamelCase							:
			'''simple docstring'''







			def __init__(     self							:	Optional[int]		)							->    None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE				: Node | None			       =    None
				SCREAMING_SNAKE_CASE				: List[Any]			       =    0
			def 							__UpperCamelCase	(     self							:	Union[str, Any] , a							:	Any		)							->    None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE				: Any			       =    Node(a , self.head		)
				self.size += 1
			def 							__UpperCamelCase	(     self							:	Dict		)							->    Any:

				"""simple docstring"""

				if self.head is None:
					return None
				else:
					SCREAMING_SNAKE_CASE				: Optional[int]			       =    self.head.item
					SCREAMING_SNAKE_CASE				: Dict			       =    self.head.next
					self.size -= 1
					return item
			def 							__UpperCamelCase	(     self							:	Any		)							->    bool:

				"""simple docstring"""

				return self.head is None
			def __str__(     self							:	Union[str, Any]		)							->    str:

				"""simple docstring"""

				if self.is_empty():
					return ""
				else:
					SCREAMING_SNAKE_CASE				: Union[str, Any]			       =    self.head
					SCREAMING_SNAKE_CASE				: str			       =    ""
					SCREAMING_SNAKE_CASE				: list[str]			       =    []
					while iterate:
						item_list.append(str(iterate.item		)		)
						SCREAMING_SNAKE_CASE				: str			       =    iterate.next

					SCREAMING_SNAKE_CASE				: List[str]			       =    " --> ".join(a		)

					return item_str






			def __len__(     self							:	List[Any]		)							->    int:

				"""simple docstring"""

				return self.size