
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 ,     _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 ,     )				->				Dict:
          SCREAMING_SNAKE_CASE_	=      parent
          SCREAMING_SNAKE_CASE_	=      batch_size
          SCREAMING_SNAKE_CASE_	=      image_size
          SCREAMING_SNAKE_CASE_	=      num_channels
          SCREAMING_SNAKE_CASE_	=      kernel_sizes
          SCREAMING_SNAKE_CASE_	=      in_channels
          SCREAMING_SNAKE_CASE_	=      out_channels
          SCREAMING_SNAKE_CASE_	=      strides
          SCREAMING_SNAKE_CASE_	=      num_block_repeats
          SCREAMING_SNAKE_CASE_	=      expand_ratios
          SCREAMING_SNAKE_CASE_	=      is_training
          SCREAMING_SNAKE_CASE_	=      hidden_act
          SCREAMING_SNAKE_CASE_	=      num_labels
          SCREAMING_SNAKE_CASE_	=      use_labels



       def     _UpperCamelCase	(							self	)				->				str:
          SCREAMING_SNAKE_CASE_	=      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

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

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



       def     _UpperCamelCase	(							self	)				->				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     _UpperCamelCase	(							self ,     _A ,     _A ,     _A	)				->				Optional[Any]:
          SCREAMING_SNAKE_CASE_	=      EfficientNetModel(config=_A	)
          model.to(_A	)
          model.eval()
          SCREAMING_SNAKE_CASE_	=      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     _UpperCamelCase	(							self ,     _A ,     _A ,     _A	)				->				str:
          SCREAMING_SNAKE_CASE_	=      EfficientNetForImageClassification(_A	)
          model.to(_A	)
          model.eval()
          SCREAMING_SNAKE_CASE_	=      model(_A ,     labels=_A	)
          self.parent.assertEqual(result.logits.shape ,     (self.batch_size, self.num_labels)	)




       def     _UpperCamelCase	(							self	)				->				Optional[Any]:
          SCREAMING_SNAKE_CASE_	=      self.prepare_config_and_inputs()
          SCREAMING_SNAKE_CASE_	, SCREAMING_SNAKE_CASE_	, SCREAMING_SNAKE_CASE_	=      config_and_inputs
          SCREAMING_SNAKE_CASE_	=      {'''pixel_values''': pixel_values}
          return config, inputs_dict







@require_torch
class 				UpperCamelCase__		(	__SCREAMING_SNAKE_CASE       ,    __SCREAMING_SNAKE_CASE       ,    unittest.TestCase	):






       """simple docstring"""


       UpperCAmelCase_				       =(EfficientNetModel, EfficientNetForImageClassification) if is_torch_available() else ()
       UpperCAmelCase_				       =(
           {"feature-extraction": EfficientNetModel, "image-classification": EfficientNetForImageClassification}
           if is_torch_available()
           else {}
       )

       UpperCAmelCase_				       =False
       UpperCAmelCase_				       =False
       UpperCAmelCase_				       =False
       UpperCAmelCase_				       =False
       UpperCAmelCase_				       =False



       def     _UpperCamelCase	(							self	)				->				Any:
          SCREAMING_SNAKE_CASE_	=      EfficientNetModelTester(self	)
          SCREAMING_SNAKE_CASE_	=      ConfigTester(
              self ,     config_class=_A ,     has_text_modality=_A ,     hidden_size=37	)



       def     _UpperCamelCase	(							self	)				->				Tuple:
          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	)				->				Tuple:
          return



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



       @unittest.skip(reason='''EfficientNet does not support input and output embeddings'''	)
       def     _UpperCamelCase	(							self	)				->				str:
          pass



       @unittest.skip(reason='''EfficientNet does not use feedforward chunking'''	)
       def     _UpperCamelCase	(							self	)				->				Optional[Any]:
          pass



       def     _UpperCamelCase	(							self	)				->				Tuple:
          SCREAMING_SNAKE_CASE_	, SCREAMING_SNAKE_CASE_	=      self.model_tester.prepare_config_and_inputs_for_common()

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

             SCREAMING_SNAKE_CASE_	=      ['''pixel_values''']
             self.assertListEqual(arg_names[:1] ,     _A	)



       def     _UpperCamelCase	(							self	)				->				int:
          SCREAMING_SNAKE_CASE_	=      self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*_A	)



       def     _UpperCamelCase	(							self	)				->				List[str]:
          def check_hidden_states_output(_A ,     _A ,     _A	):
             SCREAMING_SNAKE_CASE_	=      model_class(_A	)
             model.to(_A	)
             model.eval()

             with torch.no_grad():
                SCREAMING_SNAKE_CASE_	=      model(**self._prepare_for_class(_A ,     _A	)	)

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

          SCREAMING_SNAKE_CASE_	, SCREAMING_SNAKE_CASE_	=      self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
             SCREAMING_SNAKE_CASE_	=      True
             check_hidden_states_output(_A ,     _A ,     _A	)

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

             check_hidden_states_output(_A ,     _A ,     _A	)



       def     _UpperCamelCase	(							self	)				->				Optional[int]:
          SCREAMING_SNAKE_CASE_	=      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     _UpperCamelCase	(							self	)				->				List[str]:
          pass



       @slow
       def     _UpperCamelCase	(							self	)				->				Dict:
          for model_name in EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             SCREAMING_SNAKE_CASE_	=      EfficientNetModel.from_pretrained(_A	)
             self.assertIsNotNone(_A	)




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







def  A__ (       ):
   SCREAMING_SNAKE_CASE_	=      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	)				->				List[Any]:
          return AutoImageProcessor.from_pretrained('''google/efficientnet-b7'''	) if is_vision_available() else None




       @slow
       def     _UpperCamelCase	(							self	)				->				Any:
          SCREAMING_SNAKE_CASE_	=      EfficientNetForImageClassification.from_pretrained('''google/efficientnet-b7'''	).to(_A	)

          SCREAMING_SNAKE_CASE_	=      self.default_image_processor
          SCREAMING_SNAKE_CASE_	=      prepare_img()
          SCREAMING_SNAKE_CASE_	=      image_processor(images=_A ,     return_tensors='''pt'''	).to(_A	)

          # forward pass
          with torch.no_grad():
             SCREAMING_SNAKE_CASE_	=      model(**_A	)

          # verify the logits
          SCREAMING_SNAKE_CASE_	=      torch.Size((1, 1000)	)
          self.assertEqual(outputs.logits.shape ,     _A	)

          SCREAMING_SNAKE_CASE_	=      torch.tensor([0.0001, 0.0002, 0.0002]	).to(_A	)
          self.assertTrue(torch.allclose(outputs.logits[0, :3] ,     _A ,     atol=1E-4	)	)




import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..auto.configuration_auto import AutoConfig


__UpperCAmelCase   						=     logging.get_logger(__name__)





class 				UpperCamelCase__		(	__SCREAMING_SNAKE_CASE	):






       """simple docstring"""


       UpperCAmelCase_				       ="speech-encoder-decoder"
       UpperCAmelCase_				       =True



       def __init__(							self ,     **_A	)				->				Dict:
          super().__init__(**_A	)
          if "encoder" not in kwargs or "decoder" not in kwargs:
             raise ValueError(
                 F'''A configuraton of type {self.model_type} cannot be instantiated because not both `encoder` and'''
                 F''' `decoder` sub-configurations are passed, but only {kwargs}'''	)

          SCREAMING_SNAKE_CASE_	=      kwargs.pop('''encoder'''	)
          SCREAMING_SNAKE_CASE_	=      encoder_config.pop('''model_type'''	)
          SCREAMING_SNAKE_CASE_	=      kwargs.pop('''decoder'''	)
          SCREAMING_SNAKE_CASE_	=      decoder_config.pop('''model_type'''	)

          SCREAMING_SNAKE_CASE_	=      AutoConfig.for_model(_A ,     **_A	)
          SCREAMING_SNAKE_CASE_	=      AutoConfig.for_model(_A ,     **_A	)
          SCREAMING_SNAKE_CASE_	=      True



       @classmethod
       def     _UpperCamelCase	(							cls ,     _A ,     _A ,     **_A	)				->				PretrainedConfig:
          logger.info('''Setting `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config'''	)
          SCREAMING_SNAKE_CASE_	=      True
          SCREAMING_SNAKE_CASE_	=      True

          return cls(encoder=encoder_config.to_dict() ,     decoder=decoder_config.to_dict() ,     **_A	)




       def     _UpperCamelCase	(							self	)				->				Union[str, Any]:
          SCREAMING_SNAKE_CASE_	=      copy.deepcopy(self.__dict__	)
          SCREAMING_SNAKE_CASE_	=      self.encoder.to_dict()
          SCREAMING_SNAKE_CASE_	=      self.decoder.to_dict()
          SCREAMING_SNAKE_CASE_	=      self.__class__.model_type
          return output


