
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	:				Optional[Any]     ,     lowerCAmelCase_	:				Optional[Any]     ,     lowerCAmelCase_	:				Tuple=1_3     ,     lowerCAmelCase_	:				Dict=3_2     ,     lowerCAmelCase_	:				Dict=3     ,     lowerCAmelCase_	:				List[str]=[3, 3, 5]     ,     lowerCAmelCase_	:				List[Any]=[3_2, 1_6, 2_4]     ,     lowerCAmelCase_	:				Optional[Any]=[1_6, 2_4, 4_0]     ,     lowerCAmelCase_	:				Dict=[1, 1, 2]     ,     lowerCAmelCase_	:				Optional[Any]=[1, 1, 2]     ,     lowerCAmelCase_	:				Optional[Any]=[1, 6, 6]     ,     lowerCAmelCase_	:				Union[str, Any]=True     ,     lowerCAmelCase_	:				int=True     ,     lowerCAmelCase_	:				Union[str, Any]=3_7     ,     lowerCAmelCase_	:				str="gelu"     ,     lowerCAmelCase_	:				Union[str, Any]=1_0     ,     ):

      """simple docstring"""
      _A:    Optional[int]						     =			parent
      _A:    Dict						     =			batch_size
      _A:    List[Any]						     =			image_size
      _A:    Any						     =			num_channels
      _A:    int						     =			kernel_sizes
      _A:    Dict						     =			in_channels
      _A:    Optional[Any]						     =			out_channels
      _A:    Optional[Any]						     =			strides
      _A:    int						     =			num_block_repeats
      _A:    List[str]						     =			expand_ratios
      _A:    Dict						     =			is_training
      _A:    str						     =			hidden_act
      _A:    List[str]						     =			num_labels
      _A:    int						     =			use_labels


   def 					__magic_name__							(   self	:				Any	):

      """simple docstring"""
      _A:    Tuple						     =			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

      _A:    Tuple						     =			None
      if self.use_labels:
         _A:    Union[str, Any]						     =			ids_tensor([self.batch_size]     ,     self.num_labels	)

      _A:    int						     =			self.get_config()
      return config, pixel_values, labels


   def 					__magic_name__							(   self	:				Union[str, Any]	):

      """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 					__magic_name__							(   self	:				List[Any]     ,     lowerCAmelCase_	:				Optional[Any]     ,     lowerCAmelCase_	:				Tuple     ,     lowerCAmelCase_	:				List[str]	):

      """simple docstring"""
      _A:    Tuple						     =			EfficientNetModel(config=lowerCAmelCase_	)
      model.to(lowerCAmelCase_	)
      model.eval()
      _A:    List[str]						     =			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 					__magic_name__							(   self	:				int     ,     lowerCAmelCase_	:				Any     ,     lowerCAmelCase_	:				List[str]     ,     lowerCAmelCase_	:				Any	):

      """simple docstring"""
      _A:    Tuple						     =			EfficientNetForImageClassification(lowerCAmelCase_	)
      model.to(lowerCAmelCase_	)
      model.eval()
      _A:    str						     =			model(lowerCAmelCase_     ,     labels=lowerCAmelCase_	)
      self.parent.assertEqual(result.logits.shape     ,     (self.batch_size, self.num_labels)	)


   def 					__magic_name__							(   self	:				int	):

      """simple docstring"""
      _A:    Tuple						     =			self.prepare_config_and_inputs()
      _A     ,    _A     ,    _A:    str						     =			config_and_inputs
      _A:    str						     =			{'''pixel_values''': pixel_values}
      return config, inputs_dict






@require_torch
class UpperCAmelCase  (		SCREAMING_SNAKE_CASE__				,				SCREAMING_SNAKE_CASE__				,				unittest.TestCase  ):





   '''simple docstring'''
   __UpperCamelCase						:       Union[str, Any]												=       (EfficientNetModel, EfficientNetForImageClassification) if is_torch_available() else ()
   __UpperCamelCase						:       Optional[int]												=       (
       {'''feature-extraction''': EfficientNetModel, '''image-classification''': EfficientNetForImageClassification}
       if is_torch_available()
       else {}
   )

   __UpperCamelCase						:       Optional[Any]												=       False
   __UpperCamelCase						:       List[str]												=       False
   __UpperCamelCase						:       str												=       False
   __UpperCamelCase						:       List[Any]												=       False
   __UpperCamelCase						:       Optional[int]												=       False


   def 					__magic_name__							(   self	:				List[str]	):

      """simple docstring"""
      _A:    Dict						     =			EfficientNetModelTester(self	)
      _A:    Dict						     =			ConfigTester(
          self     ,     config_class=lowerCAmelCase_     ,     has_text_modality=lowerCAmelCase_     ,     hidden_size=3_7	)


   def 					__magic_name__							(   self	:				Union[str, 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 					__magic_name__							(   self	:				Tuple	):

      """simple docstring"""
      return


   @unittest.skip(reason='''EfficientNet does not use inputs_embeds'''	)
   def 					__magic_name__							(   self	:				Optional[Any]	):

      """simple docstring"""
      pass


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

      """simple docstring"""
      pass


   @unittest.skip(reason='''EfficientNet does not use feedforward chunking'''	)
   def 					__magic_name__							(   self	:				Optional[int]	):

      """simple docstring"""
      pass


   def 					__magic_name__							(   self	:				Optional[Any]	):

      """simple docstring"""
      _A     ,    _A:    Any						     =			self.model_tester.prepare_config_and_inputs_for_common()

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

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


   def 					__magic_name__							(   self	:				Optional[int]	):

      """simple docstring"""
      _A:    int						     =			self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*lowerCAmelCase_	)


   def 					__magic_name__							(   self	:				List[str]	):

      """simple docstring"""
      def check_hidden_states_output(lowerCAmelCase_	:				Optional[int]     ,     lowerCAmelCase_	:				Dict     ,     lowerCAmelCase_	:				Optional[Any]	):
         _A:    str						     =			model_class(lowerCAmelCase_	)
         model.to(lowerCAmelCase_	)
         model.eval()

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

         _A:    Optional[Any]						     =			outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
         _A:    Union[str, Any]						     =			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]     ,     )

      _A     ,    _A:    str						     =			self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         _A:    List[Any]						     =			True
         check_hidden_states_output(lowerCAmelCase_     ,     lowerCAmelCase_     ,     lowerCAmelCase_	)

         # check that output_hidden_states also work using config
         del inputs_dict["output_hidden_states"]
         _A:    Union[str, Any]						     =			True

         check_hidden_states_output(lowerCAmelCase_     ,     lowerCAmelCase_     ,     lowerCAmelCase_	)


   def 					__magic_name__							(   self	:				int	):

      """simple docstring"""
      _A:    List[str]						     =			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 					__magic_name__							(   self	:				int	):

      """simple docstring"""
      pass


   @slow
   def 					__magic_name__							(   self	:				int	):

      """simple docstring"""
      for model_name in EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         _A:    Optional[int]						     =			EfficientNetModel.from_pretrained(lowerCAmelCase_	)
         self.assertIsNotNone(lowerCAmelCase_	)


   @is_pipeline_test
   @require_vision
   @slow
   def 					__magic_name__							(   self	:				Optional[int]	):

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






def     lowerCamelCase__				(   ) ->  Tuple:
   _A:    Optional[Any]						     =			Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' )
   return image






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





   '''simple docstring'''


   @cached_property
   def 					__magic_name__							(   self	:				Optional[Any]	):

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


   @slow
   def 					__magic_name__							(   self	:				List[str]	):

      """simple docstring"""
      _A:    List[Any]						     =			EfficientNetForImageClassification.from_pretrained('''google/efficientnet-b7'''	).to(lowerCAmelCase_	)

      _A:    Optional[int]						     =			self.default_image_processor
      _A:    Tuple						     =			prepare_img()
      _A:    Dict						     =			image_processor(images=lowerCAmelCase_     ,     return_tensors='''pt'''	).to(lowerCAmelCase_	)

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

      # verify the logits
      _A:    Optional[Any]						     =			torch.Size((1, 1_0_0_0)	)
      self.assertEqual(outputs.logits.shape     ,     lowerCAmelCase_	)

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





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


UpperCAmelCase__						:	Any	     = {
    'configuration_decision_transformer': [
        'DECISION_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'DecisionTransformerConfig',
    ],
}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   UpperCAmelCase__						:	Optional[Any]	     = [
       'DECISION_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
       'DecisionTransformerGPT2Model',
       'DecisionTransformerGPT2PreTrainedModel',
       'DecisionTransformerModel',
       'DecisionTransformerPreTrainedModel',
   ]


if TYPE_CHECKING:
   from .configuration_decision_transformer import (
       DECISION_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
       DecisionTransformerConfig,
   )

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_decision_transformer import (
          DECISION_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
          DecisionTransformerGPTaModel,
          DecisionTransformerGPTaPreTrainedModel,
          DecisionTransformerModel,
          DecisionTransformerPreTrainedModel,
      )


else:
   import sys

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



