




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 :       int						,				A :       Tuple						,				A :       Any=13						,				A :       Optional[int]=32						,				A :       Optional[int]=3						,				A :       str=[3, 3, 5]						,				A :       Optional[Any]=[32, 16, 24]						,				A :       Optional[Any]=[16, 24, 40]						,				A :       Dict=[1, 1, 2]						,				A :       Optional[Any]=[1, 1, 2]						,				A :       int=[1, 6, 6]						,				A :       Dict=True						,				A :       Any=True						,				A :       Dict=37						,				A :       Any="gelu"						,				A :       Dict=10						,				)			->			str:






         """simple docstring"""
         a__      =       parent
         a__      =       batch_size
         a__      =       image_size
         a__      =       num_channels
         a__      =       kernel_sizes
         a__      =       in_channels
         a__      =       out_channels
         a__      =       strides
         a__      =       num_block_repeats
         a__      =       expand_ratios
         a__      =       is_training
         a__      =       hidden_act
         a__      =       num_labels
         a__      =       use_labels

     def 				__SCREAMING_SNAKE_CASE		(      self :       Optional[Any]    )			->			Any:






         """simple docstring"""
         a__      =       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

         a__      =       None
         if self.use_labels:
             a__      =       ids_tensor([self.batch_size]						,				self.num_labels    )

         a__      =       self.get_config()
         return config, pixel_values, labels

     def 				__SCREAMING_SNAKE_CASE		(      self :       Tuple    )			->			str:






         """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 				__SCREAMING_SNAKE_CASE		(      self :       List[str]						,				A :       int						,				A :       List[str]						,				A :       Optional[int]    )			->			str:






         """simple docstring"""
         a__      =       EfficientNetModel(config=A    )
         model.to(A    )
         model.eval()
         a__      =       model(A    )
         # 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 				__SCREAMING_SNAKE_CASE		(      self :       Any						,				A :       Union[str, Any]						,				A :       Optional[int]						,				A :       Union[str, Any]    )			->			int:






         """simple docstring"""
         a__      =       EfficientNetForImageClassification(A    )
         model.to(A    )
         model.eval()
         a__      =       model(A						,				labels=A    )
         self.parent.assertEqual(result.logits.shape						,				(self.batch_size, self.num_labels)    )






     def 				__SCREAMING_SNAKE_CASE		(      self :       List[str]    )			->			Tuple:






         """simple docstring"""
         a__      =       self.prepare_config_and_inputs()
         a__ ,		a__ ,		a__      =       config_and_inputs
         a__      =       {"""pixel_values""": pixel_values}
         return config, inputs_dict







@require_torch
class 		__UpperCAmelCase(		lowercase__       ,	lowercase__       ,	unittest.TestCase ):





     """simple docstring"""



     __UpperCAmelCase	: Tuple						=    (EfficientNetModel, EfficientNetForImageClassification) if is_torch_available() else ()
     __UpperCAmelCase	: Optional[int]						=    (
         {"""feature-extraction""": EfficientNetModel, """image-classification""": EfficientNetForImageClassification}
         if is_torch_available()
         else {}
     )

     __UpperCAmelCase	: Tuple						=    False
     __UpperCAmelCase	: Union[str, Any]						=    False
     __UpperCAmelCase	: Union[str, Any]						=    False
     __UpperCAmelCase	: int						=    False
     __UpperCAmelCase	: Optional[Any]						=    False

     def 				__SCREAMING_SNAKE_CASE		(      self :       Optional[Any]    )			->			Optional[Any]:






         """simple docstring"""
         a__      =       EfficientNetModelTester(self    )
         a__      =       ConfigTester(
             self						,				config_class=A						,				has_text_modality=A						,				hidden_size=37    )

     def 				__SCREAMING_SNAKE_CASE		(      self :       Any    )			->			List[Any]:






         """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 				__SCREAMING_SNAKE_CASE		(      self :       Dict    )			->			int:






         """simple docstring"""
         return

     @unittest.skip(reason="""EfficientNet does not use inputs_embeds"""    )
     def 				__SCREAMING_SNAKE_CASE		(      self :       int    )			->			Dict:






         """simple docstring"""
         pass

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






         """simple docstring"""
         pass

     @unittest.skip(reason="""EfficientNet does not use feedforward chunking"""    )
     def 				__SCREAMING_SNAKE_CASE		(      self :       List[Any]    )			->			Any:






         """simple docstring"""
         pass

     def 				__SCREAMING_SNAKE_CASE		(      self :       int    )			->			Optional[int]:






         """simple docstring"""
         a__ ,		a__      =       self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
             a__      =       model_class(A    )
             a__      =       inspect.signature(model.forward    )
             # signature.parameters is an OrderedDict => so arg_names order is deterministic
             a__      =       [*signature.parameters.keys()]

             a__      =       ["""pixel_values"""]
             self.assertListEqual(arg_names[:1]						,				A    )

     def 				__SCREAMING_SNAKE_CASE		(      self :       Optional[int]    )			->			Union[str, Any]:






         """simple docstring"""
         a__      =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*A    )

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






         """simple docstring"""
         def check_hidden_states_output(A :       Tuple						,				A :       Union[str, Any]						,				A :       List[Any]    ):
             a__      =       model_class(A    )
             model.to(A    )
             model.eval()

             with torch.no_grad():
                 a__      =       model(**self._prepare_for_class(A						,				A    )    )

             a__      =       outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
             a__      =       sum(config.num_block_repeats    ) * 4
             self.assertEqual(len(A    )						,				A    )

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

         a__ ,		a__      =       self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
             a__      =       True
             check_hidden_states_output(A						,				A						,				A    )

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

             check_hidden_states_output(A						,				A						,				A    )

     def 				__SCREAMING_SNAKE_CASE		(      self :       Union[str, Any]    )			->			Optional[Any]:






         """simple docstring"""
         a__      =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*A    )

     @unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""    )
     def 				__SCREAMING_SNAKE_CASE		(      self :       List[str]    )			->			Optional[Any]:






         """simple docstring"""
         pass

     @slow
     def 				__SCREAMING_SNAKE_CASE		(      self :       Tuple    )			->			Optional[int]:






         """simple docstring"""
         for model_name in EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             a__      =       EfficientNetModel.from_pretrained(A    )
             self.assertIsNotNone(A    )






     @is_pipeline_test
     @require_vision
     @slow
     def 				__SCREAMING_SNAKE_CASE		(      self :       Tuple    )			->			Optional[int]:






         """simple docstring"""
         super().test_pipeline_image_classification()






def        __lowerCAmelCase ():
    a__      =       Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""		)
    return image







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





     """simple docstring"""



     @cached_property
     def 				__SCREAMING_SNAKE_CASE		(      self :       Any    )			->			int:






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






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






         """simple docstring"""
         a__      =       EfficientNetForImageClassification.from_pretrained("""google/efficientnet-b7"""    ).to(A    )

         a__      =       self.default_image_processor
         a__      =       prepare_img()
         a__      =       image_processor(images=A						,				return_tensors="""pt"""    ).to(A    )

         # forward pass
         with torch.no_grad():
             a__      =       model(**A    )

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

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












from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


SCREAMING_SNAKE_CASE_						:					str			   =       {
    '''configuration_wav2vec2_conformer''': [
        '''WAV2VEC2_CONFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''Wav2Vec2ConformerConfig''',
    ],
}


try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE_						:					Optional[int]			   =       [
     '''WAV2VEC2_CONFORMER_PRETRAINED_MODEL_ARCHIVE_LIST''',
     '''Wav2Vec2ConformerForAudioFrameClassification''',
     '''Wav2Vec2ConformerForCTC''',
     '''Wav2Vec2ConformerForPreTraining''',
     '''Wav2Vec2ConformerForSequenceClassification''',
     '''Wav2Vec2ConformerForXVector''',
     '''Wav2Vec2ConformerModel''',
     '''Wav2Vec2ConformerPreTrainedModel''',
 ]

if TYPE_CHECKING:
 from .configuration_wavaveca_conformer import (
     WAV2VEC2_CONFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
     WavaVecaConformerConfig,
 )

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_wavaveca_conformer import (
      WAV2VEC2_CONFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
      WavaVecaConformerForAudioFrameClassification,
      WavaVecaConformerForCTC,
      WavaVecaConformerForPreTraining,
      WavaVecaConformerForSequenceClassification,
      WavaVecaConformerForXVector,
      WavaVecaConformerModel,
      WavaVecaConformerPreTrainedModel,
  )

else:
 import sys

 SCREAMING_SNAKE_CASE_						:					Optional[int]			   =       _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)






