




import inspect
import unittest

from transformers import RegNetConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

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 torch import nn

     from transformers import RegNetForImageClassification, RegNetModel
     from transformers.models.regnet.modeling_regnet import REGNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
     from PIL import Image

     from transformers import AutoImageProcessor






class  _lowerCAmelCase     :

      def __init__(   self      ,				__UpperCAmelCase      ,				__UpperCAmelCase=3      ,				__UpperCAmelCase=32      ,				__UpperCAmelCase=3      ,				__UpperCAmelCase=10      ,				__UpperCAmelCase=[10, 20, 30, 40]      ,				__UpperCAmelCase=[1, 1, 2, 1]      ,				__UpperCAmelCase=True      ,				__UpperCAmelCase=True      ,				__UpperCAmelCase="relu"      ,				__UpperCAmelCase=3      ,				__UpperCAmelCase=None      ,				):
        lowerCAmelCase__				:  Optional[Any]		       =     parent
        lowerCAmelCase__				:  Optional[int]		       =     batch_size
        lowerCAmelCase__				:  str		       =     image_size
        lowerCAmelCase__				:  Tuple		       =     num_channels
        lowerCAmelCase__				:  List[str]		       =     embeddings_size
        lowerCAmelCase__				:  List[str]		       =     hidden_sizes
        lowerCAmelCase__				:  Tuple		       =     depths
        lowerCAmelCase__				:  Optional[Any]		       =     is_training
        lowerCAmelCase__				:  str		       =     use_labels
        lowerCAmelCase__				:  int		       =     hidden_act
        lowerCAmelCase__				:  int		       =     num_labels
        lowerCAmelCase__				:  Any		       =     scope
        lowerCAmelCase__				:  int		       =     len(__UpperCAmelCase		)

      def 	__magic_name__(   self		):
        lowerCAmelCase__				:  Any		       =     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

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

        lowerCAmelCase__				:  Optional[int]		       =     self.get_config()

        return config, pixel_values, labels

      def 	__magic_name__(   self		):
        return RegNetConfig(
            num_channels=self.num_channels      ,				embeddings_size=self.embeddings_size      ,				hidden_sizes=self.hidden_sizes      ,				depths=self.depths      ,				hidden_act=self.hidden_act      ,				num_labels=self.num_labels      ,				)

      def 	__magic_name__(   self      ,				__UpperCAmelCase      ,				__UpperCAmelCase      ,				__UpperCAmelCase		):
        lowerCAmelCase__				:  int		       =     RegNetModel(config=__UpperCAmelCase		)
        model.to(__UpperCAmelCase		)
        model.eval()
        lowerCAmelCase__				:  int		       =     model(__UpperCAmelCase		)
        # expected last hidden states: B, C, H // 32, W // 32
        self.parent.assertEqual(
            result.last_hidden_state.shape      ,				(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)      ,				)

      def 	__magic_name__(   self      ,				__UpperCAmelCase      ,				__UpperCAmelCase      ,				__UpperCAmelCase		):
        lowerCAmelCase__				:  str		       =     self.num_labels
        lowerCAmelCase__				:  Optional[int]		       =     RegNetForImageClassification(__UpperCAmelCase		)
        model.to(__UpperCAmelCase		)
        model.eval()
        lowerCAmelCase__				:  Union[str, Any]		       =     model(__UpperCAmelCase      ,				labels=__UpperCAmelCase		)
        self.parent.assertEqual(result.logits.shape      ,				(self.batch_size, self.num_labels)		)







      def 	__magic_name__(   self		):
        lowerCAmelCase__				:  Tuple		       =     self.prepare_config_and_inputs()
        lowerCAmelCase__       ,			lowerCAmelCase__       ,			lowerCAmelCase__				:  Tuple		       =     config_and_inputs
        lowerCAmelCase__				:  Tuple		       =     {'''pixel_values''': pixel_values}
        return config, inputs_dict






@require_torch
class  _lowerCAmelCase     (  _lowercase    ,			_lowercase    ,			unittest.TestCase	):
      A__		     =		(RegNetModel, RegNetForImageClassification) if is_torch_available() else ()
      A__		     =		(
          {'feature-extraction': RegNetModel, 'image-classification': RegNetForImageClassification}
          if is_torch_available()
          else {}
      )

      A__		     =		False
      A__		     =		False
      A__		     =		False
      A__		     =		False

      def 	__magic_name__(   self		):
        lowerCAmelCase__				:  int		       =     RegNetModelTester(self		)
        lowerCAmelCase__				:  Dict		       =     ConfigTester(self      ,				config_class=__UpperCAmelCase      ,				has_text_modality=__UpperCAmelCase		)

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

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

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

      def 	__magic_name__(   self		):
        lowerCAmelCase__       ,			lowerCAmelCase__				:  Optional[int]		       =     self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
          lowerCAmelCase__				:  List[Any]		       =     model_class(__UpperCAmelCase		)
          lowerCAmelCase__				:  Dict		       =     inspect.signature(model.forward		)
          # signature.parameters is an OrderedDict => so arg_names order is deterministic
          lowerCAmelCase__				:  Tuple		       =     [*signature.parameters.keys()]

          lowerCAmelCase__				:  List[str]		       =     ['''pixel_values''']
          self.assertListEqual(arg_names[:1]      ,				__UpperCAmelCase		)

      def 	__magic_name__(   self		):
        lowerCAmelCase__				:  Tuple		       =     self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*__UpperCAmelCase		)

      def 	__magic_name__(   self		):
        lowerCAmelCase__       ,			lowerCAmelCase__				:  int		       =     self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
          lowerCAmelCase__				:  Tuple		       =     model_class(config=__UpperCAmelCase		)
          for name, module in model.named_modules():
            if isinstance(__UpperCAmelCase      ,				(nn.BatchNormad, nn.GroupNorm)		):
              self.assertTrue(
                  torch.all(module.weight == 1		)      ,				msg=f"""Parameter {name} of model {model_class} seems not properly initialized"""      ,				)
              self.assertTrue(
                  torch.all(module.bias == 0		)      ,				msg=f"""Parameter {name} of model {model_class} seems not properly initialized"""      ,				)

      def 	__magic_name__(   self		):
        def check_hidden_states_output(__UpperCAmelCase      ,				__UpperCAmelCase      ,				__UpperCAmelCase		):
          lowerCAmelCase__				:  Tuple		       =     model_class(__UpperCAmelCase		)
          model.to(__UpperCAmelCase		)
          model.eval()

          with torch.no_grad():
            lowerCAmelCase__				:  Tuple		       =     model(**self._prepare_for_class(__UpperCAmelCase      ,				__UpperCAmelCase		)		)

          lowerCAmelCase__				:  Optional[int]		       =     outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

          lowerCAmelCase__				:  Tuple		       =     self.model_tester.num_stages
          self.assertEqual(len(__UpperCAmelCase		)      ,				expected_num_stages + 1		)

          # RegNet'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__       ,			lowerCAmelCase__				:  Optional[Any]		       =     self.model_tester.prepare_config_and_inputs_for_common()
        lowerCAmelCase__				:  str		       =     ['''basic''', '''bottleneck''']
        for model_class in self.all_model_classes:
          for layer_type in layers_type:
            lowerCAmelCase__				:  Optional[int]		       =     layer_type
            lowerCAmelCase__				:  Optional[Any]		       =     True
            check_hidden_states_output(__UpperCAmelCase      ,				__UpperCAmelCase      ,				__UpperCAmelCase		)

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

            check_hidden_states_output(__UpperCAmelCase      ,				__UpperCAmelCase      ,				__UpperCAmelCase		)

      def 	__magic_name__(   self		):
        lowerCAmelCase__				:  Optional[Any]		       =     self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*__UpperCAmelCase		)







      @slow
      def 	__magic_name__(   self		):
        for model_name in REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          lowerCAmelCase__				:  Union[str, Any]		       =     RegNetModel.from_pretrained(__UpperCAmelCase		)
          self.assertIsNotNone(__UpperCAmelCase		)



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






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

      @cached_property
      def 	__magic_name__(   self		):
        return (
            AutoImageProcessor.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]		)
            if is_vision_available()
            else None
        )







      @slow
      def 	__magic_name__(   self		):
        lowerCAmelCase__				:  Optional[int]		       =     RegNetForImageClassification.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]		).to(__UpperCAmelCase		)

        lowerCAmelCase__				:  Any		       =     self.default_image_processor
        lowerCAmelCase__				:  Tuple		       =     prepare_img()
        lowerCAmelCase__				:  Tuple		       =     image_processor(images=__UpperCAmelCase      ,				return_tensors='''pt'''		).to(__UpperCAmelCase		)

        # forward pass
        with torch.no_grad():
          lowerCAmelCase__				:  Tuple		       =     model(**__UpperCAmelCase		)

        # verify the logits
        lowerCAmelCase__				:  int		       =     torch.Size((1, 1000)		)
        self.assertEqual(outputs.logits.shape      ,				__UpperCAmelCase		)

        lowerCAmelCase__				:  Union[str, Any]		       =     torch.tensor([-0.4180, -1.5051, -3.4836]		).to(__UpperCAmelCase		)

        self.assertTrue(torch.allclose(outputs.logits[0, :3]      ,				__UpperCAmelCase      ,				atol=1e-4		)		)







from tempfile import TemporaryDirectory
from unittest import TestCase
from unittest.mock import MagicMock, patch

from transformers import AutoModel, TFAutoModel
from transformers.onnx import FeaturesManager
from transformers.testing_utils import SMALL_MODEL_IDENTIFIER, require_tf, require_torch






@require_torch
@require_tf
class  _lowerCAmelCase     (  _lowercase	):

      def 	__magic_name__(   self		):
        lowerCAmelCase__				:  Union[str, Any]		       =     SMALL_MODEL_IDENTIFIER
        lowerCAmelCase__				:  List[str]		       =     '''pt'''
        lowerCAmelCase__				:  int		       =     '''tf'''

      def 	__magic_name__(   self      ,				__UpperCAmelCase		):
        lowerCAmelCase__				:  Optional[Any]		       =     AutoModel.from_pretrained(self.test_model		)
        model_pt.save_pretrained(__UpperCAmelCase		)

      def 	__magic_name__(   self      ,				__UpperCAmelCase		):
        lowerCAmelCase__				:  str		       =     TFAutoModel.from_pretrained(self.test_model      ,				from_pt=__UpperCAmelCase		)
        model_tf.save_pretrained(__UpperCAmelCase		)

      def 	__magic_name__(   self		):
        lowerCAmelCase__				:  int		       =     '''mock_framework'''

        # Framework provided - return whatever the user provides
        lowerCAmelCase__				:  Tuple		       =     FeaturesManager.determine_framework(self.test_model      ,				__UpperCAmelCase		)
        self.assertEqual(__UpperCAmelCase      ,				__UpperCAmelCase		)

        # Local checkpoint and framework provided - return provided framework
        # PyTorch checkpoint
        with TemporaryDirectory() as local_pt_ckpt:
          self._setup_pt_ckpt(__UpperCAmelCase		)
          lowerCAmelCase__				:  int		       =     FeaturesManager.determine_framework(__UpperCAmelCase      ,				__UpperCAmelCase		)
          self.assertEqual(__UpperCAmelCase      ,				__UpperCAmelCase		)

        # TensorFlow checkpoint
        with TemporaryDirectory() as local_tf_ckpt:
          self._setup_tf_ckpt(__UpperCAmelCase		)
          lowerCAmelCase__				:  List[str]		       =     FeaturesManager.determine_framework(__UpperCAmelCase      ,				__UpperCAmelCase		)
          self.assertEqual(__UpperCAmelCase      ,				__UpperCAmelCase		)

      def 	__magic_name__(   self		):
        # PyTorch checkpoint
        with TemporaryDirectory() as local_pt_ckpt:
          self._setup_pt_ckpt(__UpperCAmelCase		)
          lowerCAmelCase__				:  Tuple		       =     FeaturesManager.determine_framework(__UpperCAmelCase		)
          self.assertEqual(__UpperCAmelCase      ,				self.framework_pt		)

        # TensorFlow checkpoint
        with TemporaryDirectory() as local_tf_ckpt:
          self._setup_tf_ckpt(__UpperCAmelCase		)
          lowerCAmelCase__				:  int		       =     FeaturesManager.determine_framework(__UpperCAmelCase		)
          self.assertEqual(__UpperCAmelCase      ,				self.framework_tf		)

        # Invalid local checkpoint
        with TemporaryDirectory() as local_invalid_ckpt:
          with self.assertRaises(__UpperCAmelCase		):
            lowerCAmelCase__				:  Tuple		       =     FeaturesManager.determine_framework(__UpperCAmelCase		)







      def 	__magic_name__(   self		):
        lowerCAmelCase__				:  List[Any]		       =     MagicMock(return_value=__UpperCAmelCase		)
        with patch('''transformers.onnx.features.is_tf_available'''      ,				__UpperCAmelCase		):
          lowerCAmelCase__				:  int		       =     FeaturesManager.determine_framework(self.test_model		)
          self.assertEqual(__UpperCAmelCase      ,				self.framework_pt		)

        # PyTorch not in environment -> use TensorFlow
        lowerCAmelCase__				:  Union[str, Any]		       =     MagicMock(return_value=__UpperCAmelCase		)
        with patch('''transformers.onnx.features.is_torch_available'''      ,				__UpperCAmelCase		):
          lowerCAmelCase__				:  Optional[int]		       =     FeaturesManager.determine_framework(self.test_model		)
          self.assertEqual(__UpperCAmelCase      ,				self.framework_tf		)

        # Both in environment -> use PyTorch
        lowerCAmelCase__				:  Union[str, Any]		       =     MagicMock(return_value=__UpperCAmelCase		)
        lowerCAmelCase__				:  List[Any]		       =     MagicMock(return_value=__UpperCAmelCase		)
        with patch('''transformers.onnx.features.is_tf_available'''      ,				__UpperCAmelCase		), patch(
            '''transformers.onnx.features.is_torch_available'''      ,				__UpperCAmelCase		):
          lowerCAmelCase__				:  List[Any]		       =     FeaturesManager.determine_framework(self.test_model		)
          self.assertEqual(__UpperCAmelCase      ,				self.framework_pt		)

        # Both not in environment -> raise error
        lowerCAmelCase__				:  Optional[int]		       =     MagicMock(return_value=__UpperCAmelCase		)
        lowerCAmelCase__				:  Dict		       =     MagicMock(return_value=__UpperCAmelCase		)
        with patch('''transformers.onnx.features.is_tf_available'''      ,				__UpperCAmelCase		), patch(
            '''transformers.onnx.features.is_torch_available'''      ,				__UpperCAmelCase		):
          with self.assertRaises(__UpperCAmelCase		):
            lowerCAmelCase__				:  Tuple		       =     FeaturesManager.determine_framework(self.test_model		)

