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




       def __init__(       self				,				snake_case_				,				snake_case_=1_3				,				snake_case_=3_2				,				snake_case_=3				,				snake_case_=[3, 3, 5]				,				snake_case_=[3_2, 1_6, 2_4]				,				snake_case_=[1_6, 2_4, 4_0]				,				snake_case_=[1, 1, 2]				,				snake_case_=[1, 1, 2]				,				snake_case_=[1, 6, 6]				,				snake_case_=True				,				snake_case_=True				,				snake_case_=3_7				,				snake_case_="gelu"				,				snake_case_=1_0				,				):
         _lowerCAmelCase    :					Dict							=   parent
         _lowerCAmelCase    :					Any							=   batch_size
         _lowerCAmelCase    :					Union[str, Any]							=   image_size
         _lowerCAmelCase    :					Optional[int]							=   num_channels
         _lowerCAmelCase    :					int							=   kernel_sizes
         _lowerCAmelCase    :					int							=   in_channels
         _lowerCAmelCase    :					List[Any]							=   out_channels
         _lowerCAmelCase    :					int							=   strides
         _lowerCAmelCase    :					str							=   num_block_repeats
         _lowerCAmelCase    :					Tuple							=   expand_ratios
         _lowerCAmelCase    :					Dict							=   is_training
         _lowerCAmelCase    :					Tuple							=   hidden_act
         _lowerCAmelCase    :					Any							=   num_labels
         _lowerCAmelCase    :					str							=   use_labels




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

         _lowerCAmelCase    :					Optional[int]							=   None
         if self.use_labels:
           _lowerCAmelCase    :					Optional[int]							=   ids_tensor([self.batch_size]				,				self.num_labels					)

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







       def 							__UpperCamelCase    (       self					):
         _lowerCAmelCase    :					Optional[Any]							=   self.prepare_config_and_inputs()
         _lowerCAmelCase    :					Tuple							=   config_and_inputs
         _lowerCAmelCase    :					Any							=   {"""pixel_values""": pixel_values}
         return config, inputs_dict



@require_torch
class 					a_					(_a							,     _a							,     unittest.TestCase      ):
       __lowerCAmelCase      :			Any      = (EfficientNetModel, EfficientNetForImageClassification) if is_torch_available() else ()
       __lowerCAmelCase      :			Any      = (
           {"""feature-extraction""": EfficientNetModel, """image-classification""": EfficientNetForImageClassification}
           if is_torch_available()
           else {}
       )

       __lowerCAmelCase      :			Union[str, Any]      = False
       __lowerCAmelCase      :			Optional[Any]      = False
       __lowerCAmelCase      :			str      = False
       __lowerCAmelCase      :			Optional[Any]      = False
       __lowerCAmelCase      :			List[str]      = False




       def 							__UpperCamelCase    (       self					):
         _lowerCAmelCase    :					Dict							=   EfficientNetModelTester(self					)
         _lowerCAmelCase    :					Any							=   ConfigTester(
             self				,				config_class=snake_case_				,				has_text_modality=snake_case_				,				hidden_size=3_7					)




       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					):
         _lowerCAmelCase    :					Dict							=   self.model_tester.prepare_config_and_inputs_for_common()

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

           _lowerCAmelCase    :					str							=   ["""pixel_values"""]
           self.assertListEqual(arg_names[:1]				,				snake_case_					)




       def 							__UpperCamelCase    (       self					):
         _lowerCAmelCase    :					List[str]							=   self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*snake_case_					)




       def 							__UpperCamelCase    (       self					):
         def check_hidden_states_output(snake_case_				,				snake_case_				,				snake_case_					):
           _lowerCAmelCase    :					Optional[int]							=   model_class(snake_case_					)
           model.to(snake_case_					)
           model.eval()

           with torch.no_grad():
             _lowerCAmelCase    :					Optional[Any]							=   model(**self._prepare_for_class(snake_case_				,				snake_case_					)					)

           _lowerCAmelCase    :					Dict							=   outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
           _lowerCAmelCase    :					Union[str, Any]							=   sum(config.num_block_repeats					) * 4
           self.assertEqual(len(snake_case_					)				,				snake_case_					)

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

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

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

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

           check_hidden_states_output(snake_case_				,				snake_case_				,				snake_case_					)




       def 							__UpperCamelCase    (       self					):
         _lowerCAmelCase    :					Optional[Any]							=   self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*snake_case_					)




       @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]:
           _lowerCAmelCase    :					int							=   EfficientNetModel.from_pretrained(snake_case_					)
           self.assertIsNotNone(snake_case_					)







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



def 		_UpperCAmelCase			(					)      ->  Union[str, Any]:
  _lowerCAmelCase    :					Dict							=   Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""						)
  return image



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




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







       @slow
       def 							__UpperCamelCase    (       self					):
         _lowerCAmelCase    :					Tuple							=   EfficientNetForImageClassification.from_pretrained("""google/efficientnet-b7"""					).to(snake_case_					)

         _lowerCAmelCase    :					int							=   self.default_image_processor
         _lowerCAmelCase    :					Optional[Any]							=   prepare_img()
         _lowerCAmelCase    :					List[str]							=   image_processor(images=snake_case_				,				return_tensors="""pt"""					).to(snake_case_					)

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

         # verify the logits
         _lowerCAmelCase    :					Dict							=   torch.Size((1, 1_0_0_0)					)
         self.assertEqual(outputs.logits.shape				,				snake_case_					)

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




'''simple docstring'''

from typing import TYPE_CHECKING

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


UpperCamelCase_            =    {"""configuration_gptj""": ["""GPTJ_PRETRAINED_CONFIG_ARCHIVE_MAP""", """GPTJConfig""", """GPTJOnnxConfig"""]}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCamelCase_            =    [
         """GPTJ_PRETRAINED_MODEL_ARCHIVE_LIST""",
         """GPTJForCausalLM""",
         """GPTJForQuestionAnswering""",
         """GPTJForSequenceClassification""",
         """GPTJModel""",
         """GPTJPreTrainedModel""",
     ]

try:
     if not is_tf_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCamelCase_            =    [
         """TFGPTJForCausalLM""",
         """TFGPTJForQuestionAnswering""",
         """TFGPTJForSequenceClassification""",
         """TFGPTJModel""",
         """TFGPTJPreTrainedModel""",
     ]

try:
     if not is_flax_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCamelCase_            =    [
         """FlaxGPTJForCausalLM""",
         """FlaxGPTJModel""",
         """FlaxGPTJPreTrainedModel""",
     ]


if TYPE_CHECKING:
     from .configuration_gptj import GPTJ_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTJConfig, GPTJOnnxConfig

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_gptj import (
              GPTJ_PRETRAINED_MODEL_ARCHIVE_LIST,
              GPTJForCausalLM,
              GPTJForQuestionAnswering,
              GPTJForSequenceClassification,
              GPTJModel,
              GPTJPreTrainedModel,
          )

     try:
          if not is_tf_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_tf_gptj import (
              TFGPTJForCausalLM,
              TFGPTJForQuestionAnswering,
              TFGPTJForSequenceClassification,
              TFGPTJModel,
              TFGPTJPreTrainedModel,
          )

     try:
          if not is_flax_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_flax_gptj import FlaxGPTJForCausalLM, FlaxGPTJModel, FlaxGPTJPreTrainedModel

else:
     import sys

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


