


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 lowerCAmelCase_						:

 '''simple docstring'''

 def __init__(	self		,      _UpperCAmelCase		,      _UpperCAmelCase=13		,      _UpperCAmelCase=32		,      _UpperCAmelCase=3		,      _UpperCAmelCase=[3, 3, 5]		,      _UpperCAmelCase=[32, 16, 24]		,      _UpperCAmelCase=[16, 24, 40]		,      _UpperCAmelCase=[1, 1, 2]		,      _UpperCAmelCase=[1, 1, 2]		,      _UpperCAmelCase=[1, 6, 6]		,      _UpperCAmelCase=True		,      _UpperCAmelCase=True		,      _UpperCAmelCase=37		,      _UpperCAmelCase="gelu"		,      _UpperCAmelCase=10		,      ):
       snake_case_       =      parent
       snake_case_       =      batch_size
       snake_case_       =      image_size
       snake_case_       =      num_channels
       snake_case_       =      kernel_sizes
       snake_case_       =      in_channels
       snake_case_       =      out_channels
       snake_case_       =      strides
       snake_case_       =      num_block_repeats
       snake_case_       =      expand_ratios
       snake_case_       =      is_training
       snake_case_       =      hidden_act
       snake_case_       =      num_labels
       snake_case_       =      use_labels



 def 						UpperCamelCase__     (	self					):
       snake_case_       =      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

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

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



 def 						UpperCamelCase__     (	self					):
       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		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase					):
       snake_case_       =      EfficientNetModel(config=_UpperCAmelCase					)
       model.to(_UpperCAmelCase					)
       model.eval()
       snake_case_       =      model(_UpperCAmelCase					)
       # 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		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase					):
       snake_case_       =      EfficientNetForImageClassification(_UpperCAmelCase					)
       model.to(_UpperCAmelCase					)
       model.eval()
       snake_case_       =      model(_UpperCAmelCase		,      labels=_UpperCAmelCase					)
       self.parent.assertEqual(result.logits.shape		,      (self.batch_size, self.num_labels)					)





 def 						UpperCamelCase__     (	self					):
       snake_case_       =      self.prepare_config_and_inputs()
       snake_case_       ,    snake_case_       ,    snake_case_       =      config_and_inputs
       snake_case_       =      {'''pixel_values''': pixel_values}
       return config, inputs_dict







@require_torch
class lowerCAmelCase_						( lowerCamelCase__					,						lowerCamelCase__					,						unittest.TestCase       ):

 '''simple docstring'''

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

 __snake_case												=  False
 __snake_case												=  False
 __snake_case												=  False
 __snake_case												=  False
 __snake_case												=  False



 def 						UpperCamelCase__     (	self					):
       snake_case_       =      EfficientNetModelTester(self					)
       snake_case_       =      ConfigTester(
           self		,      config_class=_UpperCAmelCase		,      has_text_modality=_UpperCAmelCase		,      hidden_size=37					)



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



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



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



 @unittest.skip(reason='''EfficientNet does not use feedforward chunking'''					)
 def 						UpperCamelCase__     (	self					):
       pass



 def 						UpperCamelCase__     (	self					):
       snake_case_       ,    snake_case_       =      self.model_tester.prepare_config_and_inputs_for_common()

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

             snake_case_       =      ['''pixel_values''']
             self.assertListEqual(arg_names[:1]		,      _UpperCAmelCase					)



 def 						UpperCamelCase__     (	self					):
       snake_case_       =      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_UpperCAmelCase					)



 def 						UpperCamelCase__     (	self					):
       def check_hidden_states_output(_UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase					):
             snake_case_       =      model_class(_UpperCAmelCase					)
             model.to(_UpperCAmelCase					)
             model.eval()

             with torch.no_grad():
                   snake_case_       =      model(**self._prepare_for_class(_UpperCAmelCase		,      _UpperCAmelCase					)					)

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

             # 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_       =      self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
             snake_case_       =      True
             check_hidden_states_output(_UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase					)

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

             check_hidden_states_output(_UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase					)



 def 						UpperCamelCase__     (	self					):
       snake_case_       =      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*_UpperCAmelCase					)



 @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''					)
 def 						UpperCamelCase__     (	self					):
       pass



 @slow
 def 						UpperCamelCase__     (	self					):
       for model_name in EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             snake_case_       =      EfficientNetModel.from_pretrained(_UpperCAmelCase					)
             self.assertIsNotNone(_UpperCAmelCase					)





 @is_pipeline_test
 @require_vision
 @slow
 def 						UpperCamelCase__     (	self					):
       super().test_pipeline_image_classification()






def        __lowerCAmelCase    ()->  Optional[int]:




      """simple docstring"""

      snake_case_       =      Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''					)
      return image







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

 '''simple docstring'''

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





 @slow
 def 						UpperCamelCase__     (	self					):
       snake_case_       =      EfficientNetForImageClassification.from_pretrained('''google/efficientnet-b7'''					).to(_UpperCAmelCase					)

       snake_case_       =      self.default_image_processor
       snake_case_       =      prepare_img()
       snake_case_       =      image_processor(images=_UpperCAmelCase		,      return_tensors='''pt'''					).to(_UpperCAmelCase					)

       # forward pass
       with torch.no_grad():
             snake_case_       =      model(**_UpperCAmelCase					)

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

       snake_case_       =      torch.tensor([0.0_001, 0.0_002, 0.0_002]					).to(_UpperCAmelCase					)
       self.assertTrue(torch.allclose(outputs.logits[0, :3]		,      _UpperCAmelCase		,      atol=1E-4					)					)



from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


UpperCAmelCase			=    {
    """configuration_big_bird""": ["""BIG_BIRD_PRETRAINED_CONFIG_ARCHIVE_MAP""", """BigBirdConfig""", """BigBirdOnnxConfig"""],
}

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

try:
   if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   UpperCAmelCase			=    ["""BigBirdTokenizerFast"""]

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   UpperCAmelCase			=    [
       """BIG_BIRD_PRETRAINED_MODEL_ARCHIVE_LIST""",
       """BigBirdForCausalLM""",
       """BigBirdForMaskedLM""",
       """BigBirdForMultipleChoice""",
       """BigBirdForPreTraining""",
       """BigBirdForQuestionAnswering""",
       """BigBirdForSequenceClassification""",
       """BigBirdForTokenClassification""",
       """BigBirdLayer""",
       """BigBirdModel""",
       """BigBirdPreTrainedModel""",
       """load_tf_weights_in_big_bird""",
   ]

try:
   if not is_flax_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   UpperCAmelCase			=    [
       """FlaxBigBirdForCausalLM""",
       """FlaxBigBirdForMaskedLM""",
       """FlaxBigBirdForMultipleChoice""",
       """FlaxBigBirdForPreTraining""",
       """FlaxBigBirdForQuestionAnswering""",
       """FlaxBigBirdForSequenceClassification""",
       """FlaxBigBirdForTokenClassification""",
       """FlaxBigBirdModel""",
       """FlaxBigBirdPreTrainedModel""",
   ]

if TYPE_CHECKING:
   from .configuration_big_bird import BIG_BIRD_PRETRAINED_CONFIG_ARCHIVE_MAP, BigBirdConfig, BigBirdOnnxConfig

   try:
      if not is_sentencepiece_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .tokenization_big_bird import BigBirdTokenizer

   try:
      if not is_tokenizers_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .tokenization_big_bird_fast import BigBirdTokenizerFast

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_big_bird import (
          BIG_BIRD_PRETRAINED_MODEL_ARCHIVE_LIST,
          BigBirdForCausalLM,
          BigBirdForMaskedLM,
          BigBirdForMultipleChoice,
          BigBirdForPreTraining,
          BigBirdForQuestionAnswering,
          BigBirdForSequenceClassification,
          BigBirdForTokenClassification,
          BigBirdLayer,
          BigBirdModel,
          BigBirdPreTrainedModel,
          load_tf_weights_in_big_bird,
      )

   try:
      if not is_flax_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_flax_big_bird import (
          FlaxBigBirdForCausalLM,
          FlaxBigBirdForMaskedLM,
          FlaxBigBirdForMultipleChoice,
          FlaxBigBirdForPreTraining,
          FlaxBigBirdForQuestionAnswering,
          FlaxBigBirdForSequenceClassification,
          FlaxBigBirdForTokenClassification,
          FlaxBigBirdModel,
          FlaxBigBirdPreTrainedModel,
      )

else:
   import sys

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