


'''simple docstring'''




import gc
import importlib.metadata
import tempfile
import unittest

from packaging import version

from transformers import (
    AutoModel,
    AutoModelForCausalLM,
    AutoModelForSeqaSeqLM,
    AutoModelForSequenceClassification,
    AutoTokenizer,
    BitsAndBytesConfig,
    pipeline,
)
from transformers.testing_utils import (
    is_torch_available,
    require_accelerate,
    require_bitsandbytes,
    require_torch,
    require_torch_gpu,
    require_torch_multi_gpu,
    slow,
)





def   _a		(lowercase__			:   Optional[Any]						)			->			List[str]:






     """simple docstring"""
     if model.config.model_type == "gpt2":
          return model.transformer.h[0].mlp.c_fc
     return model.transformer.h[0].mlp.dense_ah_to_h


if is_torch_available():
       import torch
       import torch.nn as nn




       class 			_lowercase (	nn.Module							):
          def __init__(						self       :      Dict       ,   SCREAMING_SNAKE_CASE_       :      nn.Module       ,   SCREAMING_SNAKE_CASE_       :      int      ) ->							str:
               super().__init__()
               __snake_case           =						module
               __snake_case           =						nn.Sequential(
                   nn.Linear(module.in_features       ,   SCREAMING_SNAKE_CASE_       ,   bias=SCREAMING_SNAKE_CASE_      )       ,   nn.Linear(SCREAMING_SNAKE_CASE_       ,   module.out_features       ,   bias=SCREAMING_SNAKE_CASE_      )       ,   )
               __snake_case           =						(2.0 / (5 * min(module.in_features       ,   module.out_features      ))) ** 0.5
               nn.init.normal_(self.adapter[0].weight       ,   std=SCREAMING_SNAKE_CASE_      )
               nn.init.zeros_(self.adapter[1].weight      )
               self.adapter.to(module.weight.device      )





          def a  (						self       :      Optional[Any]       ,   SCREAMING_SNAKE_CASE_       :      Any       ,   *SCREAMING_SNAKE_CASE_       :      List[Any]       ,   **SCREAMING_SNAKE_CASE_       :      List[str]      ) ->							Union[str, Any]:
               return self.module(SCREAMING_SNAKE_CASE_       ,   *SCREAMING_SNAKE_CASE_       ,   **SCREAMING_SNAKE_CASE_      ) + self.adapter(SCREAMING_SNAKE_CASE_      )




@require_bitsandbytes
@require_accelerate
@require_torch
@require_torch_gpu
@slow
class 			_lowercase (	unittest.TestCase							):
   # We keep the constants inside the init function and model loading inside setUp function

   # We need to test on relatively large models (aka >1b parameters otherwise the quantiztion may not work as expected)
   # Therefore here we use only bloom-1b3 to test our module
   _SCREAMING_SNAKE_CASE  :  Tuple          =	"bigscience/bloom-1b7"

   # Constant values
   _SCREAMING_SNAKE_CASE  :  Union[str, Any]          =	2.109659552692574

   _SCREAMING_SNAKE_CASE  :  Optional[Any]          =	"Hello my name is"
   _SCREAMING_SNAKE_CASE  :  List[str]          =	set()
   EXPECTED_OUTPUTS.add("Hello my name is John and I am a professional photographer. I"							)
   EXPECTED_OUTPUTS.add("Hello my name is John.\nI am a friend of your father.\n"							)
   EXPECTED_OUTPUTS.add("Hello my name is John Doe, I am a student at the University"							)
   _SCREAMING_SNAKE_CASE  :  Dict          =	1_0
   def a  (						self       :      Optional[Any]      ) ->							List[Any]:
        # Models and tokenizer
        __snake_case           =						AutoTokenizer.from_pretrained(self.model_name      )




class 			_lowercase (	__lowercase							):
   def a  (						self       :      Union[str, Any]      ) ->							List[str]:
        super().setUp()

        # Models and tokenizer
        __snake_case           =						AutoModelForCausalLM.from_pretrained(
            self.model_name       ,   torch_dtype=torch.floataa       ,   device_map='auto'      )
        __snake_case           =						AutoModelForCausalLM.from_pretrained(self.model_name       ,   load_in_abit=SCREAMING_SNAKE_CASE_       ,   device_map='auto'      )
   def a  (						self       :      Optional[Any]      ) ->							Any:
        del self.model_fpaa
        del self.model_abit

        gc.collect()
        torch.cuda.empty_cache()
   def a  (						self       :      Optional[Any]      ) ->							int:
        __snake_case           =						self.model_abit.config

        self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_       ,   'quantization_config'      )      )

        __snake_case           =						config.to_dict()
        __snake_case           =						config.to_diff_dict()

        __snake_case           =						config.to_json_string()
   def a  (						self       :      Optional[Any]      ) ->							str:
        from bitsandbytes.nn import Paramsabit

        __snake_case           =						self.model_fpaa.get_memory_footprint()
        __snake_case           =						self.model_abit.get_memory_footprint()

        self.assertAlmostEqual(mem_fpaa / mem_abit       ,   self.EXPECTED_RELATIVE_DIFFERENCE      )
        __snake_case           =						get_some_linear_layer(self.model_abit      )
        self.assertTrue(linear.weight.__class__ == Paramsabit      )
   def a  (						self       :      Union[str, Any]      ) ->							Optional[Any]:
        from transformers import TaPreTrainedModel

        self.model_fpaa.get_memory_footprint()
        self.model_abit.get_memory_footprint()

        for name, module in self.model_abit.named_modules():
             if isinstance(SCREAMING_SNAKE_CASE_       ,   torch.nn.Linear      ):
                  if name not in ["lm_head"] + TaPreTrainedModel._keep_in_fpaa_modules:
                       # 4-bit parameters are packed in uint8 variables
                       self.assertTrue(module.weight.dtype == torch.uinta      )
   def a  (						self       :      Union[str, Any]      ) ->							int:
        __snake_case           =						self.tokenizer(self.input_text       ,   return_tensors='pt'      )
        __snake_case           =						self.model_abit.generate(input_ids=encoded_input['input_ids'].to(0      )       ,   max_new_tokens=10      )

        self.assertIn(self.tokenizer.decode(output_sequences[0]       ,   skip_special_tokens=SCREAMING_SNAKE_CASE_      )       ,   self.EXPECTED_OUTPUTS      )
   def a  (						self       :      Optional[Any]      ) ->							Dict:
        __snake_case           =						BitsAndBytesConfig()
        __snake_case           =						True

        __snake_case           =						AutoModelForCausalLM.from_pretrained(
            self.model_name       ,   quantization_config=SCREAMING_SNAKE_CASE_       ,   device_map='auto'      )

        __snake_case           =						self.tokenizer(self.input_text       ,   return_tensors='pt'      )
        __snake_case           =						model_abit_from_config.generate(
            input_ids=encoded_input['input_ids'].to(0      )       ,   max_new_tokens=10      )

        self.assertIn(self.tokenizer.decode(output_sequences[0]       ,   skip_special_tokens=SCREAMING_SNAKE_CASE_      )       ,   self.EXPECTED_OUTPUTS      )
   def a  (						self       :      List[Any]      ) ->							str:
        with self.assertRaises(SCREAMING_SNAKE_CASE_      ), tempfile.TemporaryDirectory() as tmpdirname:
             self.model_abit.save_pretrained(SCREAMING_SNAKE_CASE_      )
   def a  (						self       :      Any      ) ->							Union[str, Any]:
        __snake_case           =						BitsAndBytesConfig()

        with self.assertRaises(SCREAMING_SNAKE_CASE_      ):
             __snake_case           =						AutoModelForCausalLM.from_pretrained(
                 self.model_name       ,   quantization_config=SCREAMING_SNAKE_CASE_       ,   load_in_abit=SCREAMING_SNAKE_CASE_       ,   device_map='auto'       ,   bnb_abit_quant_type='nf4'       ,   )
   def a  (						self       :      Tuple      ) ->							Dict:
        with self.assertRaises(SCREAMING_SNAKE_CASE_      ):
             # Tries with `str`
             self.model_abit.to('cpu'      )

        with self.assertRaises(SCREAMING_SNAKE_CASE_      ):
             # Tries with a `dtype``
             self.model_abit.to(torch.floataa      )

        with self.assertRaises(SCREAMING_SNAKE_CASE_      ):
             # Tries with a `device`
             self.model_abit.to(torch.device('cuda:0'      )      )

        with self.assertRaises(SCREAMING_SNAKE_CASE_      ):
             # Tries with a `device`
             self.model_abit.float()

        with self.assertRaises(SCREAMING_SNAKE_CASE_      ):
             # Tries with a `device`
             self.model_abit.half()

        # Test if we did not break anything
        __snake_case           =						self.tokenizer(self.input_text       ,   return_tensors='pt'      )

        __snake_case           =						self.model_fpaa.to(torch.floataa      )
        __snake_case           =						self.model_fpaa.generate(input_ids=encoded_input['input_ids'].to(0      )       ,   max_new_tokens=10      )

        # Check this does not throw an error
        __snake_case           =						self.model_fpaa.to('cpu'      )

        # Check this does not throw an error
        __snake_case           =						self.model_fpaa.half()

        # Check this does not throw an error
        __snake_case           =						self.model_fpaa.float()





   def a  (						self       :      Tuple      ) ->							Union[str, Any]:
        __snake_case           =						AutoModelForSeqaSeqLM.from_pretrained('t5-small'       ,   load_in_abit=SCREAMING_SNAKE_CASE_       ,   device_map='auto'      )
        self.assertTrue(model.decoder.block[0].layer[2].DenseReluDense.wo.weight.dtype == torch.floataa      )




@require_bitsandbytes
@require_accelerate
@require_torch
@require_torch_gpu
@slow
class 			_lowercase (	unittest.TestCase							):
   @classmethod
   def a  (						cls       :      Union[str, Any]      ) ->							Dict:
        __snake_case           =						't5-small'
        __snake_case           =						'google/flan-t5-small'  # flan-t5 uses dense-act instead of dense-relu-dense
        __snake_case           =						AutoTokenizer.from_pretrained(cls.model_name      )
        __snake_case           =						'Translate in German: Hello, my dog is cute'
   def a  (						self       :      List[Any]      ) ->							str:
        gc.collect()
        torch.cuda.empty_cache()
   def a  (						self       :      int      ) ->							Optional[Any]:
        from transformers import TaForConditionalGeneration

        __snake_case           =						TaForConditionalGeneration._keep_in_fpaa_modules
        __snake_case           =						None

        # test with `t5-small`
        __snake_case           =						TaForConditionalGeneration.from_pretrained(self.model_name       ,   load_in_abit=SCREAMING_SNAKE_CASE_       ,   device_map='auto'      )
        __snake_case           =						self.tokenizer(self.input_text       ,   return_tensors='pt'      ).to(0      )
        __snake_case           =						model.generate(**SCREAMING_SNAKE_CASE_      )

        # test with `flan-t5-small`
        __snake_case           =						TaForConditionalGeneration.from_pretrained(
            self.dense_act_model_name       ,   load_in_abit=SCREAMING_SNAKE_CASE_       ,   device_map='auto'      )
        __snake_case           =						self.tokenizer(self.input_text       ,   return_tensors='pt'      ).to(0      )
        __snake_case           =						model.generate(**SCREAMING_SNAKE_CASE_      )
        __snake_case           =						modules





   def a  (						self       :      List[str]      ) ->							Any:
        import bitsandbytes as bnb

        from transformers import TaForConditionalGeneration

        # test with `t5-small`
        __snake_case           =						TaForConditionalGeneration.from_pretrained(self.model_name       ,   load_in_abit=SCREAMING_SNAKE_CASE_       ,   device_map='auto'      )

        # there was a bug with decoders - this test checks that it is fixed
        self.assertTrue(isinstance(model.decoder.block[0].layer[0].SelfAttention.q       ,   bnb.nn.Linearabit      )      )

        __snake_case           =						self.tokenizer(self.input_text       ,   return_tensors='pt'      ).to(0      )
        __snake_case           =						model.generate(**SCREAMING_SNAKE_CASE_      )

        # test with `flan-t5-small`
        __snake_case           =						TaForConditionalGeneration.from_pretrained(
            self.dense_act_model_name       ,   load_in_abit=SCREAMING_SNAKE_CASE_       ,   device_map='auto'      )
        __snake_case           =						self.tokenizer(self.input_text       ,   return_tensors='pt'      ).to(0      )
        __snake_case           =						model.generate(**SCREAMING_SNAKE_CASE_      )




class 			_lowercase (	__lowercase							):
   def a  (						self       :      Dict      ) ->							str:
        super().setUp()
        # model_name
        __snake_case           =						'bigscience/bloom-560m'
        __snake_case           =						't5-small'

        # Different types of model

        __snake_case           =						AutoModel.from_pretrained(self.model_name       ,   load_in_abit=SCREAMING_SNAKE_CASE_       ,   device_map='auto'      )
        # Sequence classification model
        __snake_case           =						AutoModelForSequenceClassification.from_pretrained(
            self.model_name       ,   load_in_abit=SCREAMING_SNAKE_CASE_       ,   device_map='auto'      )
        # CausalLM model
        __snake_case           =						AutoModelForCausalLM.from_pretrained(self.model_name       ,   load_in_abit=SCREAMING_SNAKE_CASE_       ,   device_map='auto'      )
        # Seq2seq model
        __snake_case           =						AutoModelForSeqaSeqLM.from_pretrained(
            self.seq_to_seq_name       ,   load_in_abit=SCREAMING_SNAKE_CASE_       ,   device_map='auto'      )
   def a  (						self       :      int      ) ->							Dict:
        del self.base_model
        del self.sequence_model
        del self.model_abit
        del self.seq_to_seq_model

        gc.collect()
        torch.cuda.empty_cache()





   def a  (						self       :      Any      ) ->							Optional[Any]:
        from bitsandbytes.nn import Paramsabit

        self.assertTrue(self.base_model.h[-1].mlp.dense_ah_to_h.weight.__class__ == Paramsabit      )

        # Other heads should be nn.Parameter
        self.assertTrue(self.model_abit.lm_head.weight.__class__ == torch.nn.Parameter      )
        self.assertTrue(self.sequence_model.score.weight.__class__ == torch.nn.Parameter      )
        self.assertTrue(self.seq_to_seq_model.lm_head.weight.__class__ == torch.nn.Parameter      )




class 			_lowercase (	__lowercase							):
   def a  (						self       :      str      ) ->							Union[str, Any]:
        super().setUp()
   def a  (						self       :      Optional[Any]      ) ->							str:
        del self.pipe

        gc.collect()
        torch.cuda.empty_cache()





   def a  (						self       :      Optional[int]      ) ->							List[str]:
        __snake_case           =						pipeline(
            'text-generation'       ,   model=self.model_name       ,   model_kwargs={'device_map': 'auto', 'load_in_4bit': True, 'torch_dtype': torch.floataa}       ,   max_new_tokens=self.MAX_NEW_TOKENS       ,   )

        # Real second forward pass
        __snake_case           =						self.pipe(self.input_text      )
        self.assertIn(pipeline_output[0]['generated_text']       ,   self.EXPECTED_OUTPUTS      )




@require_torch_multi_gpu
class 			_lowercase (	__lowercase							):
   def a  (						self       :      Optional[int]      ) ->							Union[str, Any]:
        super().setUp()





   def a  (						self       :      Optional[int]      ) ->							List[Any]:
        __snake_case           =						AutoModelForCausalLM.from_pretrained(
            self.model_name       ,   load_in_abit=SCREAMING_SNAKE_CASE_       ,   device_map='balanced'      )

        # Check correct device map
        self.assertEqual(set(model_parallel.hf_device_map.values()      )       ,   {0, 1}      )

        # Check that inference pass works on the model
        __snake_case           =						self.tokenizer(self.input_text       ,   return_tensors='pt'      )

        # Second real batch
        __snake_case           =						model_parallel.generate(input_ids=encoded_input['input_ids'].to(0      )       ,   max_new_tokens=10      )
        self.assertIn(self.tokenizer.decode(output_parallel[0]       ,   skip_special_tokens=SCREAMING_SNAKE_CASE_      )       ,   self.EXPECTED_OUTPUTS      )




class 			_lowercase (	__lowercase							):
   def a  (						self       :      Any      ) ->							str:
        __snake_case           =						'facebook/opt-350m'
        super().setUp()





   def a  (						self       :      int      ) ->							List[Any]:
        if version.parse(importlib.metadata.version('bitsandbytes'      )      ) < version.parse('0.37.0'      ):
             return

        # Step 1: freeze all parameters
        __snake_case           =						AutoModelForCausalLM.from_pretrained(self.model_name       ,   load_in_abit=SCREAMING_SNAKE_CASE_      )

        self.assertEqual(set(model.hf_device_map.values()      )       ,   {torch.cuda.current_device()}      )

        for param in model.parameters():
             __snake_case           =						False  # freeze the model - train adapters later
             if param.ndim == 1:
                  # cast the small parameters (e.g. layernorm) to fp32 for stability
                  __snake_case           =						param.data.to(torch.floataa      )

        # Step 2: add adapters
        for _, module in model.named_modules():
             if "OPTAttention" in repr(type(SCREAMING_SNAKE_CASE_      )      ):
                  __snake_case           =						LoRALayer(module.q_proj       ,   rank=16      )
                  __snake_case           =						LoRALayer(module.k_proj       ,   rank=16      )
                  __snake_case           =						LoRALayer(module.v_proj       ,   rank=16      )

        # Step 3: dummy batch
        __snake_case           =						self.tokenizer('Test batch '       ,   return_tensors='pt'      ).to(0      )

        # Step 4: Check if the gradient is not None
        with torch.cuda.amp.autocast():
             __snake_case           =						model.forward(**SCREAMING_SNAKE_CASE_      )
             out.logits.norm().backward()

        for module in model.modules():
             if isinstance(SCREAMING_SNAKE_CASE_       ,   SCREAMING_SNAKE_CASE_      ):
                  self.assertTrue(module.adapter[1].weight.grad is not None      )
                  self.assertTrue(module.adapter[1].weight.grad.norm().item() > 0      )
             elif isinstance(SCREAMING_SNAKE_CASE_       ,   nn.Embedding      ):
                  self.assertTrue(module.weight.grad is None      )




class 			_lowercase (	__lowercase							):
   _SCREAMING_SNAKE_CASE  :  Union[str, Any]          =	"gpt2-xl"
   _SCREAMING_SNAKE_CASE  :  Optional[int]          =	3.3191854854152187






import inspect
import unittest

from transformers import ConvNextVaConfig
from transformers.models.auto import get_values
from transformers.models.auto.modeling_auto import MODEL_FOR_BACKBONE_MAPPING_NAMES, MODEL_MAPPING_NAMES
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_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 ConvNextVaBackbone, ConvNextVaForImageClassification, ConvNextVaModel
   from transformers.models.convnextva.modeling_convnextva import CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
   from PIL import Image

   from transformers import AutoImageProcessor






class     UpperCAmelCase						:



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


          '''simple docstring'''


          snake_case			:  Union[str, Any]     							= parent
          snake_case			:  Optional[int]     							= batch_size
          snake_case			:  Optional[Any]     							= image_size
          snake_case			:  Union[str, Any]     							= num_channels
          snake_case			:  Tuple     							= num_stages
          snake_case			:  Union[str, Any]     							= hidden_sizes
          snake_case			:  List[Any]     							= depths
          snake_case			:  Dict     							= is_training
          snake_case			:  List[Any]     							= use_labels
          snake_case			:  str     							= intermediate_size
          snake_case			:  Dict     							= hidden_act
          snake_case			:  Optional[int]     							= num_labels
          snake_case			:  Dict     							= initializer_range
          snake_case			:  List[Any]     							= out_features
          snake_case			:  int     							= out_indices
          snake_case			:  List[Any]     							= scope



   def 							_SCREAMING_SNAKE_CASE  (self						:   Tuple					)						->      List[str]:


          '''simple docstring'''


          snake_case			:  List[Any]     							= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

          snake_case			:  List[Any]     							= None
          if self.use_labels:
                 snake_case			:  List[Any]     							= ids_tensor([self.batch_size]       ,		self.num_labels					)

          snake_case			:  str     							= self.get_config()

          return config, pixel_values, labels



   def 							_SCREAMING_SNAKE_CASE  (self						:   Any					)						->      Dict:


          '''simple docstring'''


          return ConvNextVaConfig(
              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 							_SCREAMING_SNAKE_CASE  (self						:   Optional[Any]       ,		snake_case__						:   str       ,		snake_case__						:   int       ,		snake_case__						:   List[Any]					)						->      Union[str, Any]:


          '''simple docstring'''


          snake_case			:  List[str]     							= ConvNextVaModel(config=snake_case__					)
          model.to(snake_case__					)
          model.eval()
          snake_case			:  Any     							= 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 // 32, self.image_size // 32)       ,		)



   def 							_SCREAMING_SNAKE_CASE  (self						:   Union[str, Any]       ,		snake_case__						:   Optional[Any]       ,		snake_case__						:   str       ,		snake_case__						:   List[Any]					)						->      Tuple:


          '''simple docstring'''


          snake_case			:  str     							= ConvNextVaForImageClassification(snake_case__					)
          model.to(snake_case__					)
          model.eval()
          snake_case			:  Tuple     							= model(snake_case__       ,		labels=snake_case__					)
          self.parent.assertEqual(result.logits.shape       ,		(self.batch_size, self.num_labels)					)



   def 							_SCREAMING_SNAKE_CASE  (self						:   Optional[Any]       ,		snake_case__						:   Dict       ,		snake_case__						:   int       ,		snake_case__						:   Optional[int]					)						->      int:


          '''simple docstring'''


          snake_case			:  int     							= ConvNextVaBackbone(config=snake_case__					)
          model.to(snake_case__					)
          model.eval()
          snake_case			:  Union[str, Any]     							= 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			:  Dict     							= None
          snake_case			:  Tuple     							= ConvNextVaBackbone(config=snake_case__					)
          model.to(snake_case__					)
          model.eval()
          snake_case			:  int     							= 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 							_SCREAMING_SNAKE_CASE  (self						:   Optional[int]					)						->      Union[str, Any]:


          '''simple docstring'''


          snake_case			:  str     							= self.prepare_config_and_inputs()
          snake_case							,   snake_case							,   snake_case			:  Union[str, Any]     							= config_and_inputs
          snake_case			:  int     							= {"pixel_values": pixel_values}
          return config, inputs_dict



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


          '''simple docstring'''


          snake_case			:  Optional[int]     							= self.prepare_config_and_inputs()
          snake_case							,   snake_case							,   snake_case			:  str     							= config_and_inputs
          snake_case			:  Optional[int]     							= {"pixel_values": pixel_values, "labels": labels}
          return config, inputs_dict






@require_torch
class     UpperCAmelCase						(		A_			,A_			,unittest.TestCase					):
   A__   :						Tuple			=	(
       (
           ConvNextVaModel,
           ConvNextVaForImageClassification,
           ConvNextVaBackbone,
       )
       if is_torch_available()
       else ()
   )
   A__   :						int			=	(
       {"feature-extraction": ConvNextVaModel, "image-classification": ConvNextVaForImageClassification}
       if is_torch_available()
       else {}
   )

   A__   :						str			=	False
   A__   :						Dict			=	False
   A__   :						Optional[int]			=	False
   A__   :						List[Any]			=	False
   A__   :						str			=	False



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


          '''simple docstring'''


          snake_case			:  Optional[Any]     							= ConvNextVaModelTester(self					)
          snake_case			:  int     							= ConfigTester(self       ,		config_class=snake_case__       ,		has_text_modality=snake_case__       ,		hidden_size=37					)



   def 							_SCREAMING_SNAKE_CASE  (self						:   str					)						->      Tuple:


          '''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					)						->      Dict:


          '''simple docstring'''


          return



   @unittest.skip(reason="ConvNextV2 does not use inputs_embeds"					)
   def 							_SCREAMING_SNAKE_CASE  (self						:   List[Any]					)						->      Optional[int]:


          '''simple docstring'''


          pass



   @unittest.skip(reason="ConvNextV2 does not support input and output embeddings"					)
   def 							_SCREAMING_SNAKE_CASE  (self						:   int					)						->      Optional[Any]:


          '''simple docstring'''


          pass



   @unittest.skip(reason="ConvNextV2 does not use feedforward chunking"					)
   def 							_SCREAMING_SNAKE_CASE  (self						:   Optional[int]					)						->      List[str]:


          '''simple docstring'''


          pass



   def 							_SCREAMING_SNAKE_CASE  (self						:   Tuple					)						->      Optional[int]:


          '''simple docstring'''


          if not self.model_tester.is_training:
                 return

          for model_class in self.all_model_classes:
                 snake_case							,   snake_case			:  str     							= self.model_tester.prepare_config_and_inputs_with_labels()
                 snake_case			:  Tuple     							= True

                 if model_class.__name__ in [
                     *get_values(snake_case__					),
                     *get_values(snake_case__					),
                 ]:
                        continue

                 snake_case			:  Union[str, Any]     							= model_class(snake_case__					)
                 model.to(snake_case__					)
                 model.train()
                 snake_case			:  str     							= self._prepare_for_class(snake_case__       ,		snake_case__       ,		return_labels=snake_case__					)
                 snake_case			:  List[str]     							= model(**snake_case__					).loss
                 loss.backward()



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


          '''simple docstring'''


          if not self.model_tester.is_training:
                 return

          for model_class in self.all_model_classes:
                 snake_case							,   snake_case			:  List[str]     							= self.model_tester.prepare_config_and_inputs_with_labels()
                 snake_case			:  List[Any]     							= False
                 snake_case			:  Any     							= True

                 if (
                     model_class.__name__
                     in [*get_values(snake_case__					), *get_values(snake_case__					)]
                     or not model_class.supports_gradient_checkpointing
                 ):
                        continue

                 snake_case			:  Union[str, Any]     							= model_class(snake_case__					)
                 model.to(snake_case__					)
                 model.gradient_checkpointing_enable()
                 model.train()
                 snake_case			:  List[str]     							= self._prepare_for_class(snake_case__       ,		snake_case__       ,		return_labels=snake_case__					)
                 snake_case			:  Any     							= model(**snake_case__					).loss
                 loss.backward()



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


          '''simple docstring'''


          snake_case							,   snake_case			:  Optional[Any]     							= self.model_tester.prepare_config_and_inputs_for_common()

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

                 snake_case			:  Any     							= ["pixel_values"]
                 self.assertListEqual(arg_names[:1]       ,		snake_case__					)



   def 							_SCREAMING_SNAKE_CASE  (self						:   Optional[int]					)						->      Optional[int]:


          '''simple docstring'''


          snake_case			:  Optional[Any]     							= self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*snake_case__					)



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


          '''simple docstring'''


          def check_hidden_states_output(snake_case__						:   Dict       ,		snake_case__						:   List[Any]       ,		snake_case__						:   Dict					):
                 snake_case			:  List[str]     							= model_class(snake_case__					)
                 model.to(snake_case__					)
                 model.eval()

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

                 snake_case			:  List[Any]     							= outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

                 snake_case			:  Dict     							= self.model_tester.num_stages
                 self.assertEqual(len(snake_case__					)       ,		expected_num_stages + 1					)

                 # ConvNextV2'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			:  int     							= self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
                 snake_case			:  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"]
                 snake_case			:  int     							= True

                 check_hidden_states_output(snake_case__       ,		snake_case__       ,		snake_case__					)



   def 							_SCREAMING_SNAKE_CASE  (self						:   Optional[Any]					)						->      Union[str, Any]:


          '''simple docstring'''


          snake_case			:  Union[str, Any]     							= self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_image_classification(*snake_case__					)



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


          '''simple docstring'''


          for model_name in CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 snake_case			:  Optional[int]     							= ConvNextVaModel.from_pretrained(snake_case__					)
                 self.assertIsNotNone(snake_case__					)



def      UpperCamelCase   (       ):
       snake_case			:  Dict     							= Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"       )
       return image






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



   @cached_property
   def 							_SCREAMING_SNAKE_CASE  (self						:   Tuple					)						->      Any:


          '''simple docstring'''


          return AutoImageProcessor.from_pretrained("facebook/convnextv2-tiny-1k-224"					) if is_vision_available() else None



   @slow
   def 							_SCREAMING_SNAKE_CASE  (self						:   Tuple					)						->      List[Any]:


          '''simple docstring'''


          snake_case			:  Union[str, Any]     							= ConvNextVaForImageClassification.from_pretrained("facebook/convnextv2-tiny-1k-224"					).to(snake_case__					)

          snake_case			:  List[str]     							= self.default_image_processor
          snake_case			:  str     							= prepare_img()
          snake_case			:  List[str]     							= preprocessor(images=snake_case__       ,		return_tensors="pt"					).to(snake_case__					)

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

          # verify the logits
          snake_case			:  Any     							= torch.Size((1, 10_00)					)
          self.assertEqual(outputs.logits.shape       ,		snake_case__					)

          snake_case			:  str     							= torch.tensor([0.9996, 0.1966, -0.4386]					).to(snake_case__					)
          self.assertTrue(torch.allclose(outputs.logits[0, :3]       ,		snake_case__       ,		atol=1e-4					)					)





