


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







    """simple docstring"""

    def __init__(	self      , __snake_case      , __snake_case=1_3      , __snake_case=3_2      , __snake_case=3      , __snake_case=4      , __snake_case=[1_0, 2_0, 3_0, 4_0]      , __snake_case=[2, 2, 3, 2]      , __snake_case=True      , __snake_case=True      , __snake_case=3_7      , __snake_case="gelu"      , __snake_case=1_0      , __snake_case=0.02      , __snake_case=["stage2", "stage3", "stage4"]      , __snake_case=[2, 3, 4]      , __snake_case=None      , ):
         snake_case					=    parent
         snake_case					=    batch_size
         snake_case					=    image_size
         snake_case					=    num_channels
         snake_case					=    num_stages
         snake_case					=    hidden_sizes
         snake_case					=    depths
         snake_case					=    is_training
         snake_case					=    use_labels
         snake_case					=    intermediate_size
         snake_case					=    hidden_act
         snake_case					=    num_labels
         snake_case					=    initializer_range
         snake_case					=    out_features
         snake_case					=    out_indices
         snake_case					=    scope
    def 		a_      (	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 		a_      (	self   ):
         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=__snake_case      , initializer_range=self.initializer_range      , out_features=self.out_features      , out_indices=self.out_indices      , num_labels=self.num_labels      , )
    def 		a_      (	self      , __snake_case      , __snake_case      , __snake_case   ):
         snake_case					=    ConvNextModel(config=__snake_case   )
         model.to(__snake_case   )
         model.eval()
         snake_case					=    model(__snake_case   )
         # 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 		a_      (	self      , __snake_case      , __snake_case      , __snake_case   ):
         snake_case					=    ConvNextForImageClassification(__snake_case   )
         model.to(__snake_case   )
         model.eval()
         snake_case					=    model(__snake_case      , labels=__snake_case   )
         self.parent.assertEqual(result.logits.shape      , (self.batch_size, self.num_labels)   )
    def 		a_      (	self      , __snake_case      , __snake_case      , __snake_case   ):
         snake_case					=    ConvNextBackbone(config=__snake_case   )
         model.to(__snake_case   )
         model.eval()
         snake_case					=    model(__snake_case   )

         # 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
         snake_case					=    None
         snake_case					=    ConvNextBackbone(config=__snake_case   )
         model.to(__snake_case   )
         model.eval()
         snake_case					=    model(__snake_case   )

         # 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   ):
         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   A__ (   snake_case__	, snake_case__	, unittest.TestCase     ):







    """simple docstring"""

    __magic_name__        =		(
        (
            ConvNextModel,
            ConvNextForImageClassification,
            ConvNextBackbone,
        )
        if is_torch_available()
        else ()
    )
    __magic_name__        =		(
        {'feature-extraction': ConvNextModel, 'image-classification': ConvNextForImageClassification}
        if is_torch_available()
        else {}
    )

    __magic_name__        =		True
    __magic_name__        =		False
    __magic_name__        =		False
    __magic_name__        =		False
    __magic_name__        =		False
    def 		a_      (	self   ):
         snake_case					=    ConvNextModelTester(self   )
         snake_case					=    ConfigTester(self      , config_class=__snake_case      , has_text_modality=__snake_case      , hidden_size=3_7   )
    def 		a_      (	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 		a_      (	self   ):
         return
    @unittest.skip(reason='''ConvNext does not use inputs_embeds'''   )
    def 		a_      (	self   ):
         pass
    @unittest.skip(reason='''ConvNext does not support input and output embeddings'''   )
    def 		a_      (	self   ):
         pass
    @unittest.skip(reason='''ConvNext does not use feedforward chunking'''   )
    def 		a_      (	self   ):
         pass
    def 		a_      (	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(__snake_case   )
              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]      , __snake_case   )
    def 		a_      (	self   ):
         snake_case					=    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*__snake_case   )
    def 		a_      (	self   ):
         snake_case					=    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_backbone(*__snake_case   )
    def 		a_      (	self   ):
         def check_hidden_states_output(__snake_case      , __snake_case      , __snake_case   ):
              snake_case					=    model_class(__snake_case   )
              model.to(__snake_case   )
              model.eval()

              with torch.no_grad():
                   snake_case					=    model(**self._prepare_for_class(__snake_case      , __snake_case   )   )

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

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

         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(__snake_case      , __snake_case      , __snake_case   )

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

              check_hidden_states_output(__snake_case      , __snake_case      , __snake_case   )
    def 		a_      (	self   ):
         snake_case					=    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*__snake_case   )




    @slow
    def 		a_      (	self   ):
         for model_name in CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              snake_case					=    ConvNextModel.from_pretrained(__snake_case   )
              self.assertIsNotNone(__snake_case   )






def       UpperCAmelCase__						():



     """simple docstring"""






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

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







    """simple docstring"""

    @cached_property
    def 		a_      (	self   ):
         return AutoImageProcessor.from_pretrained('''facebook/convnext-tiny-224'''   ) if is_vision_available() else None




    @slow
    def 		a_      (	self   ):
         snake_case					=    ConvNextForImageClassification.from_pretrained('''facebook/convnext-tiny-224'''   ).to(__snake_case   )

         snake_case					=    self.default_image_processor
         snake_case					=    prepare_img()
         snake_case					=    image_processor(images=__snake_case      , return_tensors='''pt'''   ).to(__snake_case   )

         # forward pass
         with torch.no_grad():
              snake_case					=    model(**__snake_case   )

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

         snake_case					=    torch.tensor([-0.0260, -0.4739, 0.1911]   ).to(__snake_case   )

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






@require_torch
class   A__ (   unittest.TestCase	, snake_case__     ):







    """simple docstring"""

    __magic_name__        =		(ConvNextBackbone,) if is_torch_available() else ()
    __magic_name__        =		ConvNextConfig

    __magic_name__        =		False
    def 		a_      (	self   ):
         snake_case					=    ConvNextModelTester(self   )








import warnings

from ...utils import logging
from .image_processing_beit import BeitImageProcessor


_SCREAMING_SNAKE_CASE      :			List[str]      				=   logging.get_logger(__name__)

class   A__ (   snake_case__     ):







    """simple docstring"""

    def __init__(	self      , *__snake_case      , **__snake_case   ):
         warnings.warn(
             '''The class BeitFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please'''
             ''' use BeitImageProcessor instead.'''      , __snake_case      , )
         super().__init__(*__snake_case      , **__snake_case   )




