

'''simple docstring'''
import inspect
import unittest

from transformers import ConvNextConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
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 ConvNextBackbone, ConvNextForImageClassification, ConvNextModel
     from transformers.models.convnext.modeling_convnext import CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
     from PIL import Image

     from transformers import AutoImageProcessor







class 							A__   :





  def __init__(		self				:     Optional[int]							, _a				:     str							, _a				:     List[Any]=13							, _a				:     Optional[int]=32							, _a				:     Union[str, Any]=3							, _a				:     str=4							, _a				:     Any=[10, 20, 30, 40]							, _a				:     Optional[Any]=[2, 2, 3, 2]							, _a				:     List[str]=True							, _a				:     List[str]=True							, _a				:     Tuple=37							, _a				:     Optional[Any]="gelu"							, _a				:     Union[str, Any]=10							, _a				:     int=0.02							, _a				:     List[str]=["stage2", "stage3", "stage4"]							, _a				:     str=[2, 3, 4]							, _a				:     Union[str, Any]=None							, )     ->   int:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =parent
       _SCREAMING_SNAKE_CASE							   =batch_size
       _SCREAMING_SNAKE_CASE							   =image_size
       _SCREAMING_SNAKE_CASE							   =num_channels
       _SCREAMING_SNAKE_CASE							   =num_stages
       _SCREAMING_SNAKE_CASE							   =hidden_sizes
       _SCREAMING_SNAKE_CASE							   =depths
       _SCREAMING_SNAKE_CASE							   =is_training
       _SCREAMING_SNAKE_CASE							   =use_labels
       _SCREAMING_SNAKE_CASE							   =intermediate_size
       _SCREAMING_SNAKE_CASE							   =hidden_act
       _SCREAMING_SNAKE_CASE							   =num_labels
       _SCREAMING_SNAKE_CASE							   =initializer_range
       _SCREAMING_SNAKE_CASE							   =out_features
       _SCREAMING_SNAKE_CASE							   =out_indices
       _SCREAMING_SNAKE_CASE							   =scope





  def 						A  (		self				:     Optional[int]			)     ->   Optional[Any]:





       '''simple docstring'''






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

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

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





  def 						A  (		self				:     Union[str, Any]			)     ->   List[Any]:





       '''simple docstring'''






       return ConvNextConfig(
           num_channels=self.num_channels							, hidden_sizes=self.hidden_sizes							, depths=self.depths							, num_stages=self.num_stages							, hidden_act=self.hidden_act							, is_decoder=a_							, initializer_range=self.initializer_range							, out_features=self.out_features							, out_indices=self.out_indices							, num_labels=self.num_labels							, )





  def 						A  (		self				:     Union[str, Any]							, _a				:     Union[str, Any]							, _a				:     Any							, _a				:     Optional[int]			)     ->   Optional[Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =ConvNextModel(config=a_			)
       model.to(a_			)
       model.eval()
       _SCREAMING_SNAKE_CASE							   =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 // 32, self.image_size // 32)							, )





  def 						A  (		self				:     List[str]							, _a				:     Dict							, _a				:     Union[str, Any]							, _a				:     Union[str, Any]			)     ->   str:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =ConvNextForImageClassification(a_			)
       model.to(a_			)
       model.eval()
       _SCREAMING_SNAKE_CASE							   =model(a_							, labels=a_			)
       self.parent.assertEqual(result.logits.shape							, (self.batch_size, self.num_labels)			)





  def 						A  (		self				:     int							, _a				:     Union[str, Any]							, _a				:     List[Any]							, _a				:     Optional[Any]			)     ->   Tuple:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =ConvNextBackbone(config=a_			)
       model.to(a_			)
       model.eval()
       _SCREAMING_SNAKE_CASE							   =model(a_			)

       # verify hidden states
       self.parent.assertEqual(len(result.feature_maps			)							, len(config.out_features			)			)
       self.parent.assertListEqual(list(result.feature_maps[0].shape			)							, [self.batch_size, self.hidden_sizes[1], 4, 4]			)

       # verify channels
       self.parent.assertEqual(len(model.channels			)							, len(config.out_features			)			)
       self.parent.assertListEqual(model.channels							, config.hidden_sizes[1:]			)

       # verify backbone works with out_features=None
       _SCREAMING_SNAKE_CASE							   =None
       _SCREAMING_SNAKE_CASE							   =ConvNextBackbone(config=a_			)
       model.to(a_			)
       model.eval()
       _SCREAMING_SNAKE_CASE							   =model(a_			)

       # verify feature maps
       self.parent.assertEqual(len(result.feature_maps			)							, 1			)
       self.parent.assertListEqual(list(result.feature_maps[0].shape			)							, [self.batch_size, self.hidden_sizes[-1], 1, 1]			)

       # verify channels
       self.parent.assertEqual(len(model.channels			)							, 1			)
       self.parent.assertListEqual(model.channels							, [config.hidden_sizes[-1]]			)





  def 						A  (		self				:     Optional[Any]			)     ->   Optional[Any]:





       '''simple docstring'''






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







@require_torch
class 							A__   (	__snake_case					,       __snake_case					,       unittest.TestCase  ):
  A__					=    (
      (
          ConvNextModel,
          ConvNextForImageClassification,
          ConvNextBackbone,
      )
      if is_torch_available()
      else ()
  )
  A__					=    (
      {'feature-extraction': ConvNextModel, 'image-classification': ConvNextForImageClassification}
      if is_torch_available()
      else {}
  )

  A__					=    True
  A__					=    False
  A__					=    False
  A__					=    False
  A__					=    False





  def 						A  (		self				:     Union[str, Any]			)     ->   Tuple:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =ConvNextModelTester(self			)
       _SCREAMING_SNAKE_CASE							   =ConfigTester(self							, config_class=a_							, has_text_modality=a_							, hidden_size=37			)





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





       '''simple docstring'''






       return





  @unittest.skip(reason='ConvNext does not use inputs_embeds'			)
  def 						A  (		self				:     List[str]			)     ->   Tuple:





       '''simple docstring'''






       pass





  @unittest.skip(reason='ConvNext does not support input and output embeddings'			)
  def 						A  (		self				:     Tuple			)     ->   List[Any]:





       '''simple docstring'''






       pass





  @unittest.skip(reason='ConvNext does not use feedforward chunking'			)
  def 						A  (		self				:     List[str]			)     ->   int:





       '''simple docstring'''






       pass





  def 						A  (		self				:     Optional[Any]			)     ->   Tuple:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.model_tester.prepare_config_and_inputs_for_common()

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

            _SCREAMING_SNAKE_CASE							   =['''pixel_values''']
            self.assertListEqual(arg_names[:1]							, a_			)





  def 						A  (		self				:     Any			)     ->   Dict:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*a_			)





  def 						A  (		self				:     List[Any]			)     ->   Tuple:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_backbone(*a_			)





  def 						A  (		self				:     List[Any]			)     ->   List[Any]:





       '''simple docstring'''






       def check_hidden_states_output(_a				:     Dict							, _a				:     Dict							, _a				:     str			):
            _SCREAMING_SNAKE_CASE							   =model_class(a_			)
            model.to(a_			)
            model.eval()

            with torch.no_grad():
                 _SCREAMING_SNAKE_CASE							   =model(**self._prepare_for_class(a_							, a_			)			)

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

            _SCREAMING_SNAKE_CASE							   =self.model_tester.num_stages
            self.assertEqual(len(a_			)							, expected_num_stages + 1			)

            # ConvNext'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 // 4, self.model_tester.image_size // 4]							, )

       _SCREAMING_SNAKE_CASE							   =self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
            _SCREAMING_SNAKE_CASE							   =True
            check_hidden_states_output(a_							, a_							, a_			)

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

            check_hidden_states_output(a_							, a_							, a_			)





  def 						A  (		self				:     List[Any]			)     ->   Union[str, Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*a_			)





  @slow
  def 						A  (		self				:     List[Any]			)     ->   Dict:





       '''simple docstring'''






       for model_name in CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            _SCREAMING_SNAKE_CASE							   =ConvNextModel.from_pretrained(a_			)
            self.assertIsNotNone(a_			)


def 	_lowerCAmelCase (						)				->      Dict:
     """simple docstring"""




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







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





  @cached_property
  def 						A  (		self				:     Optional[int]			)     ->   Any:





       '''simple docstring'''






       return AutoImageProcessor.from_pretrained('facebook/convnext-tiny-224'			) if is_vision_available() else None





  @slow
  def 						A  (		self				:     Union[str, Any]			)     ->   int:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =ConvNextForImageClassification.from_pretrained('facebook/convnext-tiny-224'			).to(a_			)

       _SCREAMING_SNAKE_CASE							   =self.default_image_processor
       _SCREAMING_SNAKE_CASE							   =prepare_img()
       _SCREAMING_SNAKE_CASE							   =image_processor(images=a_							, return_tensors='pt'			).to(a_			)

       # forward pass
       with torch.no_grad():
            _SCREAMING_SNAKE_CASE							   =model(**a_			)

       # verify the logits
       _SCREAMING_SNAKE_CASE							   =torch.Size((1, 1000)			)
       self.assertEqual(outputs.logits.shape							, a_			)

       _SCREAMING_SNAKE_CASE							   =torch.tensor([-0.02_60, -0.47_39, 0.19_11]			).to(a_			)

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







@require_torch
class 							A__   (	unittest.TestCase					,       __snake_case  ):
  A__					=    (ConvNextBackbone,) if is_torch_available() else ()
  A__					=    ConvNextConfig

  A__					=    False





  def 						A  (		self				:     Optional[int]			)     ->   str:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =ConvNextModelTester(self			)



'''simple docstring'''
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowerCamelCase			:				List[str] 			=					{"configuration_ibert": ["IBERT_PRETRAINED_CONFIG_ARCHIVE_MAP", "IBertConfig", "IBertOnnxConfig"]}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     lowerCamelCase			:				Union[str, Any] 			=					[
         "IBERT_PRETRAINED_MODEL_ARCHIVE_LIST",
         "IBertForMaskedLM",
         "IBertForMultipleChoice",
         "IBertForQuestionAnswering",
         "IBertForSequenceClassification",
         "IBertForTokenClassification",
         "IBertModel",
         "IBertPreTrainedModel",
     ]

if TYPE_CHECKING:
     from .configuration_ibert import IBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, IBertConfig, IBertOnnxConfig

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_ibert import (
              IBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
              IBertForMaskedLM,
              IBertForMultipleChoice,
              IBertForQuestionAnswering,
              IBertForSequenceClassification,
              IBertForTokenClassification,
              IBertModel,
              IBertPreTrainedModel,
          )

else:
     import sys

     lowerCamelCase			:				str 			=					_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
