


"""simple docstring"""

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	:	List[Any]      ,       A_	:	Tuple      ,       A_	:	List[str]=3      ,       A_	:	Optional[Any]=3_2      ,       A_	:	Dict=3      ,       A_	:	Union[str, Any]=1_0      ,       A_	:	Any=[1_0, 2_0, 3_0, 4_0]      ,       A_	:	str=[1, 1, 2, 1]      ,       A_	:	Optional[int]=True      ,       A_	:	List[str]=True      ,       A_	:	Tuple="relu"      ,       A_	:	List[str]=3      ,       A_	:	Optional[int]=None      ,       ):






       '''simple docstring'''


       __lowercase									=	parent
       __lowercase									=	batch_size
       __lowercase									=	image_size
       __lowercase									=	num_channels
       __lowercase									=	embeddings_size
       __lowercase									=	hidden_sizes
       __lowercase									=	depths
       __lowercase									=	is_training
       __lowercase									=	use_labels
       __lowercase									=	hidden_act
       __lowercase									=	num_labels
       __lowercase									=	scope
       __lowercase									=	len(A_							)
      def SCREAMING_SNAKE_CASE_	(		self	:	List[str]							):






       '''simple docstring'''


       __lowercase									=	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

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

       __lowercase									=	self.get_config()

       return config, pixel_values, labels
      def SCREAMING_SNAKE_CASE_	(		self	:	Optional[Any]							):






       '''simple docstring'''


       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 SCREAMING_SNAKE_CASE_	(		self	:	Any      ,       A_	:	Optional[Any]      ,       A_	:	List[str]      ,       A_	:	Optional[int]							):






       '''simple docstring'''


       __lowercase									=	RegNetModel(config=A_							)
       model.to(A_							)
       model.eval()
       __lowercase									=	model(A_							)
       # 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 // 3_2, self.image_size // 3_2)      ,       )
      def SCREAMING_SNAKE_CASE_	(		self	:	Union[str, Any]      ,       A_	:	Union[str, Any]      ,       A_	:	Optional[int]      ,       A_	:	Optional[int]							):






       '''simple docstring'''


       __lowercase									=	self.num_labels
       __lowercase									=	RegNetForImageClassification(A_							)
       model.to(A_							)
       model.eval()
       __lowercase									=	model(A_      ,       labels=A_							)
       self.parent.assertEqual(result.logits.shape      ,       (self.batch_size, self.num_labels)							)






      def SCREAMING_SNAKE_CASE_	(		self	:	List[str]							):






       '''simple docstring'''


       __lowercase									=	self.prepare_config_and_inputs()
       __lowercase							,		__lowercase							,		__lowercase									=	config_and_inputs
       __lowercase									=	{"""pixel_values""": pixel_values}
       return config, inputs_dict






@require_torch
class    lowerCamelCase__						(		_a			,   _a			,   unittest.TestCase    ):
      a :     int											=		(RegNetModel, RegNetForImageClassification) if is_torch_available() else ()
      a :     int											=		(
          {"""feature-extraction""": RegNetModel, """image-classification""": RegNetForImageClassification}
          if is_torch_available()
          else {}
      )

      a :     int											=		False
      a :     Optional[int]											=		False
      a :     Tuple											=		False
      a :     List[Any]											=		False
      def SCREAMING_SNAKE_CASE_	(		self	:	int							):






       '''simple docstring'''


       __lowercase									=	RegNetModelTester(self							)
       __lowercase									=	ConfigTester(self      ,       config_class=A_      ,       has_text_modality=A_							)
      def SCREAMING_SNAKE_CASE_	(		self	:	List[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 SCREAMING_SNAKE_CASE_	(		self	:	int							):






       '''simple docstring'''


       return
      @unittest.skip(reason="""RegNet does not use inputs_embeds"""							)
      def SCREAMING_SNAKE_CASE_	(		self	:	Optional[Any]							):






       '''simple docstring'''


       pass
      @unittest.skip(reason="""RegNet does not support input and output embeddings"""							)
      def SCREAMING_SNAKE_CASE_	(		self	:	Optional[Any]							):






       '''simple docstring'''


       pass
      def SCREAMING_SNAKE_CASE_	(		self	:	Dict							):






       '''simple docstring'''


       __lowercase							,		__lowercase									=	self.model_tester.prepare_config_and_inputs_for_common()

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

        __lowercase									=	["""pixel_values"""]
        self.assertListEqual(arg_names[:1]      ,       A_							)
      def SCREAMING_SNAKE_CASE_	(		self	:	Union[str, Any]							):






       '''simple docstring'''


       __lowercase									=	self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*A_							)
      def SCREAMING_SNAKE_CASE_	(		self	:	Tuple							):






       '''simple docstring'''


       __lowercase							,		__lowercase									=	self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
        __lowercase									=	model_class(config=A_							)
        for name, module in model.named_modules():
         if isinstance(A_      ,       (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 SCREAMING_SNAKE_CASE_	(		self	:	List[Any]							):






       '''simple docstring'''


       def check_hidden_states_output(A_	:	Any      ,       A_	:	Optional[int]      ,       A_	:	Union[str, Any]							):
        __lowercase									=	model_class(A_							)
        model.to(A_							)
        model.eval()

        with torch.no_grad():
         __lowercase									=	model(**self._prepare_for_class(A_      ,       A_							)							)

        __lowercase									=	outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

        __lowercase									=	self.model_tester.num_stages
        self.assertEqual(len(A_							)      ,       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]      ,       )

       __lowercase							,		__lowercase									=	self.model_tester.prepare_config_and_inputs_for_common()
       __lowercase									=	["""basic""", """bottleneck"""]
       for model_class in self.all_model_classes:
        for layer_type in layers_type:
         __lowercase									=	layer_type
         __lowercase									=	True
         check_hidden_states_output(A_      ,       A_      ,       A_							)

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

         check_hidden_states_output(A_      ,       A_      ,       A_							)
      def SCREAMING_SNAKE_CASE_	(		self	:	Dict							):






       '''simple docstring'''


       __lowercase									=	self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*A_							)






      @slow
      def SCREAMING_SNAKE_CASE_	(		self	:	int							):






       '''simple docstring'''


       for model_name in REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        __lowercase									=	RegNetModel.from_pretrained(A_							)
        self.assertIsNotNone(A_							)






def lowerCAmelCase_      (				):






 """simple docstring"""







 __lowercase									=	Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png""" )
 return image





@require_torch
@require_vision
class    lowerCamelCase__						(		unittest.TestCase    ):
      @cached_property
      def SCREAMING_SNAKE_CASE_	(		self	:	Tuple							):






       '''simple docstring'''


       return (
           AutoImageProcessor.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]							)
           if is_vision_available()
           else None
       )






      @slow
      def SCREAMING_SNAKE_CASE_	(		self	:	str							):






       '''simple docstring'''


       __lowercase									=	RegNetForImageClassification.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]							).to(A_							)

       __lowercase									=	self.default_image_processor
       __lowercase									=	prepare_img()
       __lowercase									=	image_processor(images=A_      ,       return_tensors="""pt"""							).to(A_							)

       # forward pass
       with torch.no_grad():
        __lowercase									=	model(**A_							)

       # verify the logits
       __lowercase									=	torch.Size((1, 1_0_0_0)							)
       self.assertEqual(outputs.logits.shape      ,       A_							)

       __lowercase									=	torch.tensor([-0.41_80, -1.50_51, -3.48_36]							).to(A_							)

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




"""simple docstring"""

from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


UpperCAmelCase__  							={
    "configuration_data2vec_audio": ["DATA2VEC_AUDIO_PRETRAINED_CONFIG_ARCHIVE_MAP", "Data2VecAudioConfig"],
    "configuration_data2vec_text": [
        "DATA2VEC_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "Data2VecTextConfig",
        "Data2VecTextOnnxConfig",
    ],
    "configuration_data2vec_vision": [
        "DATA2VEC_VISION_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "Data2VecVisionConfig",
        "Data2VecVisionOnnxConfig",
    ],
}

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       UpperCAmelCase__  							=[
           "DATA2VEC_AUDIO_PRETRAINED_MODEL_ARCHIVE_LIST",
           "Data2VecAudioForAudioFrameClassification",
           "Data2VecAudioForCTC",
           "Data2VecAudioForSequenceClassification",
           "Data2VecAudioForXVector",
           "Data2VecAudioModel",
           "Data2VecAudioPreTrainedModel",
       ]
       UpperCAmelCase__  							=[
           "DATA2VEC_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST",
           "Data2VecTextForCausalLM",
           "Data2VecTextForMaskedLM",
           "Data2VecTextForMultipleChoice",
           "Data2VecTextForQuestionAnswering",
           "Data2VecTextForSequenceClassification",
           "Data2VecTextForTokenClassification",
           "Data2VecTextModel",
           "Data2VecTextPreTrainedModel",
       ]
       UpperCAmelCase__  							=[
           "DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST",
           "Data2VecVisionForImageClassification",
           "Data2VecVisionForMaskedImageModeling",
           "Data2VecVisionForSemanticSegmentation",
           "Data2VecVisionModel",
           "Data2VecVisionPreTrainedModel",
       ]

if is_tf_available():
       UpperCAmelCase__  							=[
           "TFData2VecVisionForImageClassification",
           "TFData2VecVisionForSemanticSegmentation",
           "TFData2VecVisionModel",
           "TFData2VecVisionPreTrainedModel",
       ]

if TYPE_CHECKING:
       from .configuration_dataavec_audio import DATA2VEC_AUDIO_PRETRAINED_CONFIG_ARCHIVE_MAP, DataaVecAudioConfig
       from .configuration_dataavec_text import (
           DATA2VEC_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP,
           DataaVecTextConfig,
           DataaVecTextOnnxConfig,
       )
       from .configuration_dataavec_vision import (
           DATA2VEC_VISION_PRETRAINED_CONFIG_ARCHIVE_MAP,
           DataaVecVisionConfig,
           DataaVecVisionOnnxConfig,
       )

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_dataavec_audio import (
                  DATA2VEC_AUDIO_PRETRAINED_MODEL_ARCHIVE_LIST,
                  DataaVecAudioForAudioFrameClassification,
                  DataaVecAudioForCTC,
                  DataaVecAudioForSequenceClassification,
                  DataaVecAudioForXVector,
                  DataaVecAudioModel,
                  DataaVecAudioPreTrainedModel,
              )
              from .modeling_dataavec_text import (
                  DATA2VEC_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
                  DataaVecTextForCausalLM,
                  DataaVecTextForMaskedLM,
                  DataaVecTextForMultipleChoice,
                  DataaVecTextForQuestionAnswering,
                  DataaVecTextForSequenceClassification,
                  DataaVecTextForTokenClassification,
                  DataaVecTextModel,
                  DataaVecTextPreTrainedModel,
              )
              from .modeling_dataavec_vision import (
                  DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST,
                  DataaVecVisionForImageClassification,
                  DataaVecVisionForMaskedImageModeling,
                  DataaVecVisionForSemanticSegmentation,
                  DataaVecVisionModel,
                  DataaVecVisionPreTrainedModel,
              )
       if is_tf_available():
              from .modeling_tf_dataavec_vision import (
                  TFDataaVecVisionForImageClassification,
                  TFDataaVecVisionForSemanticSegmentation,
                  TFDataaVecVisionModel,
                  TFDataaVecVisionPreTrainedModel,
              )

else:
       import sys

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