




'''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 					lowercase_			:





     def __init__(    self    :				Optional[Any]    ,       __lowerCamelCase    :				List[str]    ,       __lowerCamelCase    :				Dict=13    ,       __lowerCamelCase    :				List[str]=32    ,       __lowerCamelCase    :				List[str]=3    ,       __lowerCamelCase    :				str=[3, 3, 5]    ,       __lowerCamelCase    :				Union[str, Any]=[32, 16, 24]    ,       __lowerCamelCase    :				Optional[int]=[16, 24, 40]    ,       __lowerCamelCase    :				Union[str, Any]=[1, 1, 2]    ,       __lowerCamelCase    :				str=[1, 1, 2]    ,       __lowerCamelCase    :				Optional[Any]=[1, 6, 6]    ,       __lowerCamelCase    :				Union[str, Any]=True    ,       __lowerCamelCase    :				List[Any]=True    ,       __lowerCamelCase    :				str=37    ,       __lowerCamelCase    :				Optional[int]="gelu"    ,       __lowerCamelCase    :				Tuple=10    ,       ):
           snake_case__					:      List[Any]  			=						parent
           snake_case__					:      Dict  			=						batch_size
           snake_case__					:      Any  			=						image_size
           snake_case__					:      Dict  			=						num_channels
           snake_case__					:      Optional[Any]  			=						kernel_sizes
           snake_case__					:      str  			=						in_channels
           snake_case__					:      Any  			=						out_channels
           snake_case__					:      Optional[int]  			=						strides
           snake_case__					:      Union[str, Any]  			=						num_block_repeats
           snake_case__					:      Any  			=						expand_ratios
           snake_case__					:      List[str]  			=						is_training
           snake_case__					:      int  			=						hidden_act
           snake_case__					:      int  			=						num_labels
           snake_case__					:      Dict  			=						use_labels





     def  _lowerCAmelCase			(    self    :				Dict ):
           snake_case__					:      Tuple  			=						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

           snake_case__					:      Dict  			=						None
           if self.use_labels:
                 snake_case__					:      List[str]  			=						ids_tensor([self.batch_size]    ,       self.num_labels )

           snake_case__					:      List[str]  			=						self.get_config()
           return config, pixel_values, labels





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





     def  _lowerCAmelCase			(    self    :				int ):
           snake_case__					:      str  			=						self.prepare_config_and_inputs()
           snake_case__			,       snake_case__			,       snake_case__					:      Any  			=						config_and_inputs
           snake_case__					:      Any  			=						{'pixel_values': pixel_values}
           return config, inputs_dict






@require_torch
class 					lowercase_			(	lowerCAmelCase_	,					lowerCAmelCase_	,					unittest.TestCase       ):
     A_       							= (EfficientNetModel, EfficientNetForImageClassification) if is_torch_available() else ()
     A_       							= (
         {"feature-extraction": EfficientNetModel, "image-classification": EfficientNetForImageClassification}
         if is_torch_available()
         else {}
     )

     A_       							= False
     A_       							= False
     A_       							= False
     A_       							= False
     A_       							= False





     def  _lowerCAmelCase			(    self    :				List[str] ):
           snake_case__					:      Union[str, Any]  			=						EfficientNetModelTester(self )
           snake_case__					:      List[Any]  			=						ConfigTester(
               self    ,       config_class=__lowerCamelCase    ,       has_text_modality=__lowerCamelCase    ,       hidden_size=37 )





     def  _lowerCAmelCase			(    self    :				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  _lowerCAmelCase			(    self    :				Dict ):
           return





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





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





     @unittest.skip(reason='EfficientNet does not use feedforward chunking' )
     def  _lowerCAmelCase			(    self    :				Union[str, Any] ):
           pass





     def  _lowerCAmelCase			(    self    :				List[str] ):
           snake_case__			,       snake_case__					:      Union[str, Any]  			=						self.model_tester.prepare_config_and_inputs_for_common()

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

                 snake_case__					:      Union[str, Any]  			=						['pixel_values']
                 self.assertListEqual(arg_names[:1]    ,       __lowerCamelCase )





     def  _lowerCAmelCase			(    self    :				Union[str, Any] ):
           snake_case__					:      Optional[Any]  			=						self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*__lowerCamelCase )





     def  _lowerCAmelCase			(    self    :				int ):
           def check_hidden_states_output(__lowerCamelCase    :				Tuple    ,       __lowerCamelCase    :				Optional[Any]    ,       __lowerCamelCase    :				Optional[Any] ):
                 snake_case__					:      Union[str, Any]  			=						model_class(__lowerCamelCase )
                 model.to(__lowerCamelCase )
                 model.eval()

                 with torch.no_grad():
                       snake_case__					:      List[Any]  			=						model(**self._prepare_for_class(__lowerCamelCase    ,       __lowerCamelCase ) )

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

           snake_case__			,       snake_case__					:      Any  			=						self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
                 snake_case__					:      Optional[Any]  			=						True
                 check_hidden_states_output(__lowerCamelCase    ,       __lowerCamelCase    ,       __lowerCamelCase )

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

                 check_hidden_states_output(__lowerCamelCase    ,       __lowerCamelCase    ,       __lowerCamelCase )





     def  _lowerCAmelCase			(    self    :				Tuple ):
           snake_case__					:      Optional[int]  			=						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  _lowerCAmelCase			(    self    :				int ):
           pass





     @slow
     def  _lowerCAmelCase			(    self    :				Dict ):
           for model_name in EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 snake_case__					:      List[Any]  			=						EfficientNetModel.from_pretrained(__lowerCamelCase )
                 self.assertIsNotNone(__lowerCamelCase )





     @is_pipeline_test
     @require_vision
     @slow
     def  _lowerCAmelCase			(    self    :				List[Any] ):
           super().test_pipeline_image_classification()






def 		UpperCamelCase__			(		)						->      Dict:
      snake_case__					:      Tuple  			=						Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'		)
      return image






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





     @cached_property
     def  _lowerCAmelCase			(    self    :				Tuple ):
           return AutoImageProcessor.from_pretrained('google/efficientnet-b7' ) if is_vision_available() else None





     @slow
     def  _lowerCAmelCase			(    self    :				Dict ):
           snake_case__					:      Union[str, Any]  			=						EfficientNetForImageClassification.from_pretrained('google/efficientnet-b7' ).to(__lowerCamelCase )

           snake_case__					:      str  			=						self.default_image_processor
           snake_case__					:      int  			=						prepare_img()
           snake_case__					:      Any  			=						image_processor(images=__lowerCamelCase    ,       return_tensors='pt' ).to(__lowerCamelCase )

           # forward pass
           with torch.no_grad():
                 snake_case__					:      Tuple  			=						model(**__lowerCamelCase )

           # verify the logits
           snake_case__					:      List[str]  			=						torch.Size((1, 1000) )
           self.assertEqual(outputs.logits.shape    ,       __lowerCamelCase )

           snake_case__					:      Optional[int]  			=						torch.tensor([0.0_0_0_1, 0.0_0_0_2, 0.0_0_0_2] ).to(__lowerCamelCase )
           self.assertTrue(torch.allclose(outputs.logits[0, :3]    ,       __lowerCamelCase    ,       atol=1E-4 ) )






'''simple docstring'''






from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_torch_available


A_ 			=		{
    "configuration_ernie_m": ["ERNIE_M_PRETRAINED_CONFIG_ARCHIVE_MAP", "ErnieMConfig"],
}

try:
      if not is_sentencepiece_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      A_ 			=		["ErnieMTokenizer"]

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      A_ 			=		[
          "ERNIE_M_PRETRAINED_MODEL_ARCHIVE_LIST",
          "ErnieMForMultipleChoice",
          "ErnieMForQuestionAnswering",
          "ErnieMForSequenceClassification",
          "ErnieMForTokenClassification",
          "ErnieMModel",
          "ErnieMPreTrainedModel",
          "ErnieMForInformationExtraction",
      ]


if TYPE_CHECKING:
      from .configuration_ernie_m import ERNIE_M_PRETRAINED_CONFIG_ARCHIVE_MAP, ErnieMConfig

      try:
            if not is_sentencepiece_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_ernie_m import ErnieMTokenizer

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_ernie_m import (
                ERNIE_M_PRETRAINED_MODEL_ARCHIVE_LIST,
                ErnieMForInformationExtraction,
                ErnieMForMultipleChoice,
                ErnieMForQuestionAnswering,
                ErnieMForSequenceClassification,
                ErnieMForTokenClassification,
                ErnieMModel,
                ErnieMPreTrainedModel,
            )


else:
      import sys

      A_ 			=		_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
