



import argparse
from collections import OrderedDict
from pathlib import Path

import requests
import torch
from PIL import Image

from transformers import GLPNConfig, GLPNForDepthEstimation, GLPNImageProcessor
from transformers.utils import logging


logging.set_verbosity_info()
__UpperCAmelCase          =       logging.get_logger(__name__)
def 		UpperCamelCase	(   snake_case__       :    Optional[int]	)	->     List[str]:
   UpperCamelCase    :  Union[str, Any]							=	OrderedDict()
   for key, value in state_dict.items():
      if key.startswith('module.encoder'	):
         UpperCamelCase    :  Any							=	key.replace('module.encoder'       ,     'glpn.encoder'	)
      if key.startswith('module.decoder'	):
         UpperCamelCase    :  Any							=	key.replace('module.decoder'       ,     'decoder.stages'	)
      if "patch_embed" in key:
         # replace for example patch_embed1 by patch_embeddings.0
         UpperCamelCase    :  Optional[int]							=	key[key.find('patch_embed'	) + len('patch_embed'	)]
         UpperCamelCase    :  Tuple							=	key.replace(F"""patch_embed{idx}"""       ,     F"""patch_embeddings.{int(snake_case__	)-1}"""	)
      if "norm" in key:
         UpperCamelCase    :  List[Any]							=	key.replace('norm'       ,     'layer_norm'	)
      if "glpn.encoder.layer_norm" in key:
         # replace for example layer_norm1 by layer_norm.0
         UpperCamelCase    :  List[str]							=	key[key.find('glpn.encoder.layer_norm'	) + len('glpn.encoder.layer_norm'	)]
         UpperCamelCase    :  List[str]							=	key.replace(F"""layer_norm{idx}"""       ,     F"""layer_norm.{int(snake_case__	)-1}"""	)
      if "layer_norm1" in key:
         UpperCamelCase    :  List[Any]							=	key.replace('layer_norm1'       ,     'layer_norm_1'	)
      if "layer_norm2" in key:
         UpperCamelCase    :  Any							=	key.replace('layer_norm2'       ,     'layer_norm_2'	)
      if "block" in key:
         # replace for example block1 by block.0
         UpperCamelCase    :  str							=	key[key.find('block'	) + len('block'	)]
         UpperCamelCase    :  str							=	key.replace(F"""block{idx}"""       ,     F"""block.{int(snake_case__	)-1}"""	)
      if "attn.q" in key:
         UpperCamelCase    :  Optional[int]							=	key.replace('attn.q'       ,     'attention.self.query'	)
      if "attn.proj" in key:
         UpperCamelCase    :  int							=	key.replace('attn.proj'       ,     'attention.output.dense'	)
      if "attn" in key:
         UpperCamelCase    :  Dict							=	key.replace('attn'       ,     'attention.self'	)
      if "fc1" in key:
         UpperCamelCase    :  str							=	key.replace('fc1'       ,     'dense1'	)
      if "fc2" in key:
         UpperCamelCase    :  Tuple							=	key.replace('fc2'       ,     'dense2'	)
      if "linear_pred" in key:
         UpperCamelCase    :  Union[str, Any]							=	key.replace('linear_pred'       ,     'classifier'	)
      if "linear_fuse" in key:
         UpperCamelCase    :  Any							=	key.replace('linear_fuse.conv'       ,     'linear_fuse'	)
         UpperCamelCase    :  Optional[int]							=	key.replace('linear_fuse.bn'       ,     'batch_norm'	)
      if "linear_c" in key:
         # replace for example linear_c4 by linear_c.3
         UpperCamelCase    :  Dict							=	key[key.find('linear_c'	) + len('linear_c'	)]
         UpperCamelCase    :  Optional[Any]							=	key.replace(F"""linear_c{idx}"""       ,     F"""linear_c.{int(snake_case__	)-1}"""	)
      if "bot_conv" in key:
         UpperCamelCase    :  Dict							=	key.replace('bot_conv'       ,     '0.convolution'	)
      if "skip_conv1" in key:
         UpperCamelCase    :  Optional[int]							=	key.replace('skip_conv1'       ,     '1.convolution'	)
      if "skip_conv2" in key:
         UpperCamelCase    :  Tuple							=	key.replace('skip_conv2'       ,     '2.convolution'	)
      if "fusion1" in key:
         UpperCamelCase    :  Any							=	key.replace('fusion1'       ,     '1.fusion'	)
      if "fusion2" in key:
         UpperCamelCase    :  Optional[int]							=	key.replace('fusion2'       ,     '2.fusion'	)
      if "fusion3" in key:
         UpperCamelCase    :  int							=	key.replace('fusion3'       ,     '3.fusion'	)
      if "fusion" in key and "conv" in key:
         UpperCamelCase    :  Any							=	key.replace('conv'       ,     'convolutional_layer'	)
      if key.startswith('module.last_layer_depth'	):
         UpperCamelCase    :  str							=	key.replace('module.last_layer_depth'       ,     'head.head'	)
      UpperCamelCase    :  str							=	value

   return new_state_dict
def 		UpperCamelCase	(   snake_case__       :    Optional[Any]       ,     snake_case__       :    Tuple	)	->     List[str]:
   # for each of the encoder blocks:
   for i in range(config.num_encoder_blocks	):
      for j in range(config.depths[i]	):
         # read in weights + bias of keys and values (which is a single matrix in the original implementation)
         UpperCamelCase    :  Optional[int]							=	state_dict.pop(F"""glpn.encoder.block.{i}.{j}.attention.self.kv.weight"""	)
         UpperCamelCase    :  int							=	state_dict.pop(F"""glpn.encoder.block.{i}.{j}.attention.self.kv.bias"""	)
         # next, add keys and values (in that order) to the state dict
         UpperCamelCase    :  Optional[int]							=	kv_weight[
             : config.hidden_sizes[i], :
         ]
         UpperCamelCase    :  Any							=	kv_bias[: config.hidden_sizes[i]]
         UpperCamelCase    :  str							=	kv_weight[
             config.hidden_sizes[i] :, :
         ]
         UpperCamelCase    :  Union[str, Any]							=	kv_bias[config.hidden_sizes[i] :]
def 		UpperCamelCase	(   )	->     Union[str, Any]:
   UpperCamelCase    :  int							=	'http://images.cocodataset.org/val2017/000000039769.jpg'
   UpperCamelCase    :  List[Any]							=	Image.open(requests.get(snake_case__       ,     stream=snake_case__	).raw	)

   return image
@torch.no_grad()
def 		UpperCamelCase	(   snake_case__       :    List[Any]       ,     snake_case__       :    Optional[Any]       ,     snake_case__       :    Optional[Any]=False       ,     snake_case__       :    List[str]=None	)	->     List[str]:
   UpperCamelCase    :  Any							=	GLPNConfig(hidden_sizes=[64, 128, 320, 512]       ,     decoder_hidden_size=64       ,     depths=[3, 8, 27, 3]	)

   # load image processor (only resize + rescale)
   UpperCamelCase    :  Dict							=	GLPNImageProcessor()

   # prepare image
   UpperCamelCase    :  Tuple							=	prepare_img()
   UpperCamelCase    :  Dict							=	image_processor(images=snake_case__       ,     return_tensors='pt'	).pixel_values

   logger.info('Converting model...'	)

   # load original state dict
   UpperCamelCase    :  Union[str, Any]							=	torch.load(snake_case__       ,     map_location=torch.device('cpu'	)	)

   # rename keys
   UpperCamelCase    :  List[Any]							=	rename_keys(snake_case__	)

   # key and value matrices need special treatment
   read_in_k_v(snake_case__       ,     snake_case__	)

   # create HuggingFace model and load state dict
   UpperCamelCase    :  Optional[Any]							=	GLPNForDepthEstimation(snake_case__	)
   model.load_state_dict(snake_case__	)
   model.eval()

   # forward pass
   UpperCamelCase    :  List[str]							=	model(snake_case__	)
   UpperCamelCase    :  Dict							=	outputs.predicted_depth

   # verify output
   if model_name is not None:
      if "nyu" in model_name:
         UpperCamelCase    :  Any							=	torch.tensor(
             [[4.4147, 4.0873, 4.0673], [3.7890, 3.2881, 3.1525], [3.7674, 3.5423, 3.4913]]	)
      elif "kitti" in model_name:
         UpperCamelCase    :  int							=	torch.tensor(
             [[3.4291, 2.7865, 2.5151], [3.2841, 2.7021, 2.3502], [3.1147, 2.4625, 2.2481]]	)
      else:
         raise ValueError(F"""Unknown model name: {model_name}"""	)

      UpperCamelCase    :  Optional[int]							=	torch.Size([1, 480, 640]	)

      assert predicted_depth.shape == expected_shape
      assert torch.allclose(predicted_depth[0, :3, :3]       ,     snake_case__       ,     atol=1E-4	)
      print('Looks ok!'	)

   # finally, push to hub if required
   if push_to_hub:
      logger.info('Pushing model and image processor to the hub...'	)
      model.push_to_hub(
          repo_path_or_name=Path(snake_case__       ,     snake_case__	)       ,     organization='nielsr'       ,     commit_message='Add model'       ,     use_temp_dir=snake_case__       ,     )
      image_processor.push_to_hub(
          repo_path_or_name=Path(snake_case__       ,     snake_case__	)       ,     organization='nielsr'       ,     commit_message='Add image processor'       ,     use_temp_dir=snake_case__       ,     )


if __name__ == "__main__":
    __UpperCAmelCase          =       argparse.ArgumentParser()

    parser.add_argument(
        '''--checkpoint_path''',
        default=None,
        type=str,
        help='''Path to the original PyTorch checkpoint (.pth file).''',
    )
    parser.add_argument(
        '''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the folder to output PyTorch model.'''
    )
    parser.add_argument(
        '''--push_to_hub''', action='''store_true''', help='''Whether to upload the model to the HuggingFace hub.'''
    )
    parser.add_argument(
        '''--model_name''',
        default='''glpn-kitti''',
        type=str,
        help='''Name of the model in case you\'re pushing to the hub.''',
    )
    __UpperCAmelCase          =       parser.parse_args()
    convert_glpn_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub, args.model_name)








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 				lowerCAmelCase_		:
       def __init__(			self,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_=13,			SCREAMING_SNAKE_CASE_=32,			SCREAMING_SNAKE_CASE_=3,			SCREAMING_SNAKE_CASE_=4,			SCREAMING_SNAKE_CASE_=[10, 20, 30, 40],			SCREAMING_SNAKE_CASE_=[2, 2, 3, 2],			SCREAMING_SNAKE_CASE_=True,			SCREAMING_SNAKE_CASE_=True,			SCREAMING_SNAKE_CASE_=37,			SCREAMING_SNAKE_CASE_="gelu",			SCREAMING_SNAKE_CASE_=10,			SCREAMING_SNAKE_CASE_=0.02,			SCREAMING_SNAKE_CASE_=["stage2", "stage3", "stage4"],			SCREAMING_SNAKE_CASE_=[2, 3, 4],			SCREAMING_SNAKE_CASE_=None,			)     ->		Optional[int]:
          UpperCamelCase    :  Dict							=	parent
          UpperCamelCase    :  Optional[Any]							=	batch_size
          UpperCamelCase    :  Union[str, Any]							=	image_size
          UpperCamelCase    :  Union[str, Any]							=	num_channels
          UpperCamelCase    :  List[Any]							=	num_stages
          UpperCamelCase    :  Any							=	hidden_sizes
          UpperCamelCase    :  Optional[int]							=	depths
          UpperCamelCase    :  Optional[int]							=	is_training
          UpperCamelCase    :  List[str]							=	use_labels
          UpperCamelCase    :  Dict							=	intermediate_size
          UpperCamelCase    :  List[Any]							=	hidden_act
          UpperCamelCase    :  Union[str, Any]							=	num_labels
          UpperCamelCase    :  str							=	initializer_range
          UpperCamelCase    :  List[str]							=	out_features
          UpperCamelCase    :  List[str]							=	out_indices
          UpperCamelCase    :  str							=	scope
       def 					snake_case_       (			self       )     ->		Optional[Any]:
          UpperCamelCase    :  int							=	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

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

          UpperCamelCase    :  List[Any]							=	self.get_config()
          return config, pixel_values, labels
       def 					snake_case_       (			self       )     ->		Any:
          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=SCREAMING_SNAKE_CASE_,			initializer_range=self.initializer_range,			out_features=self.out_features,			out_indices=self.out_indices,			num_labels=self.num_labels,			)
       def 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )     ->		Tuple:
          UpperCamelCase    :  Dict							=	ConvNextModel(config=SCREAMING_SNAKE_CASE_       )
          model.to(SCREAMING_SNAKE_CASE_       )
          model.eval()
          UpperCamelCase    :  str							=	model(SCREAMING_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 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )     ->		Optional[Any]:
          UpperCamelCase    :  Optional[int]							=	ConvNextForImageClassification(SCREAMING_SNAKE_CASE_       )
          model.to(SCREAMING_SNAKE_CASE_       )
          model.eval()
          UpperCamelCase    :  Dict							=	model(SCREAMING_SNAKE_CASE_,			labels=SCREAMING_SNAKE_CASE_       )
          self.parent.assertEqual(result.logits.shape,			(self.batch_size, self.num_labels)       )
       def 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )     ->		Dict:
          UpperCamelCase    :  int							=	ConvNextBackbone(config=SCREAMING_SNAKE_CASE_       )
          model.to(SCREAMING_SNAKE_CASE_       )
          model.eval()
          UpperCamelCase    :  Any							=	model(SCREAMING_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
          UpperCamelCase    :  Any							=	None
          UpperCamelCase    :  List[str]							=	ConvNextBackbone(config=SCREAMING_SNAKE_CASE_       )
          model.to(SCREAMING_SNAKE_CASE_       )
          model.eval()
          UpperCamelCase    :  Tuple							=	model(SCREAMING_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 					snake_case_       (			self       )     ->		int:
          UpperCamelCase    :  Optional[int]							=	self.prepare_config_and_inputs()
          UpperCamelCase	,     UpperCamelCase	,     UpperCamelCase    :  Optional[Any]							=	config_and_inputs
          UpperCamelCase    :  str							=	{'pixel_values': pixel_values}
          return config, inputs_dict






@require_torch
class 				lowerCAmelCase_		(  a__       ,    a__       ,    unittest.TestCase							):
       UpperCAmelCase__				:					List[Any]        =  (
           (
               ConvNextModel,
               ConvNextForImageClassification,
               ConvNextBackbone,
           )
           if is_torch_available()
           else ()
       )
       UpperCAmelCase__				:					Union[str, Any]        =  (
           {"feature-extraction": ConvNextModel, "image-classification": ConvNextForImageClassification}
           if is_torch_available()
           else {}
       )

       UpperCAmelCase__				:					Dict        =  True
       UpperCAmelCase__				:					List[str]        =  False
       UpperCAmelCase__				:					Tuple        =  False
       UpperCAmelCase__				:					List[Any]        =  False
       UpperCAmelCase__				:					Tuple        =  False
       def 					snake_case_       (			self       )     ->		Optional[Any]:
          UpperCamelCase    :  Dict							=	ConvNextModelTester(self       )
          UpperCamelCase    :  int							=	ConfigTester(self,			config_class=SCREAMING_SNAKE_CASE_,			has_text_modality=SCREAMING_SNAKE_CASE_,			hidden_size=37       )
       def 					snake_case_       (			self       )     ->		List[str]:
          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 					snake_case_       (			self       )     ->		Union[str, Any]:
          return
       @unittest.skip(reason='ConvNext does not use inputs_embeds'       )
       def 					snake_case_       (			self       )     ->		List[str]:
          pass
       @unittest.skip(reason='ConvNext does not support input and output embeddings'       )
       def 					snake_case_       (			self       )     ->		str:
          pass
       @unittest.skip(reason='ConvNext does not use feedforward chunking'       )
       def 					snake_case_       (			self       )     ->		str:
          pass
       def 					snake_case_       (			self       )     ->		Any:
          UpperCamelCase	,     UpperCamelCase    :  Optional[int]							=	self.model_tester.prepare_config_and_inputs_for_common()

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

             UpperCamelCase    :  Union[str, Any]							=	['pixel_values']
             self.assertListEqual(arg_names[:1],			SCREAMING_SNAKE_CASE_       )
       def 					snake_case_       (			self       )     ->		List[str]:
          UpperCamelCase    :  Optional[int]							=	self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_       )
       def 					snake_case_       (			self       )     ->		Dict:
          UpperCamelCase    :  Optional[Any]							=	self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_backbone(*SCREAMING_SNAKE_CASE_       )
       def 					snake_case_       (			self       )     ->		Dict:
          def check_hidden_states_output(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       ):
             UpperCamelCase    :  List[Any]							=	model_class(SCREAMING_SNAKE_CASE_       )
             model.to(SCREAMING_SNAKE_CASE_       )
             model.eval()

             with torch.no_grad():
                UpperCamelCase    :  List[Any]							=	model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )       )

             UpperCamelCase    :  List[str]							=	outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

             UpperCamelCase    :  int							=	self.model_tester.num_stages
             self.assertEqual(len(SCREAMING_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],			)

          UpperCamelCase	,     UpperCamelCase    :  Tuple							=	self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
             UpperCamelCase    :  Optional[int]							=	True
             check_hidden_states_output(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )

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

             check_hidden_states_output(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )
       def 					snake_case_       (			self       )     ->		List[str]:
          UpperCamelCase    :  List[Any]							=	self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE_       )






       @slow
       def 					snake_case_       (			self       )     ->		Tuple:
          for model_name in CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             UpperCamelCase    :  Union[str, Any]							=	ConvNextModel.from_pretrained(SCREAMING_SNAKE_CASE_       )
             self.assertIsNotNone(SCREAMING_SNAKE_CASE_       )






def 		UpperCamelCase	(   )	->     int:
   UpperCamelCase    :  Optional[int]							=	Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'	)
   return image



@require_torch
@require_vision
class 				lowerCAmelCase_		(  unittest.TestCase							):
       @cached_property
       def 					snake_case_       (			self       )     ->		Optional[int]:
          return AutoImageProcessor.from_pretrained('facebook/convnext-tiny-224'       ) if is_vision_available() else None






       @slow
       def 					snake_case_       (			self       )     ->		str:
          UpperCamelCase    :  Dict							=	ConvNextForImageClassification.from_pretrained('facebook/convnext-tiny-224'       ).to(SCREAMING_SNAKE_CASE_       )

          UpperCamelCase    :  Union[str, Any]							=	self.default_image_processor
          UpperCamelCase    :  Any							=	prepare_img()
          UpperCamelCase    :  List[str]							=	image_processor(images=SCREAMING_SNAKE_CASE_,			return_tensors='pt'       ).to(SCREAMING_SNAKE_CASE_       )

          # forward pass
          with torch.no_grad():
             UpperCamelCase    :  Optional[Any]							=	model(**SCREAMING_SNAKE_CASE_       )

          # verify the logits
          UpperCamelCase    :  List[Any]							=	torch.Size((1, 1000)       )
          self.assertEqual(outputs.logits.shape,			SCREAMING_SNAKE_CASE_       )

          UpperCamelCase    :  List[str]							=	torch.tensor([-0.02_60, -0.47_39, 0.19_11]       ).to(SCREAMING_SNAKE_CASE_       )

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






@require_torch
class 				lowerCAmelCase_		(  unittest.TestCase       ,    a__							):
       UpperCAmelCase__				:					Tuple        =  (ConvNextBackbone,) if is_torch_available() else ()
       UpperCAmelCase__				:					List[str]        =  ConvNextConfig

       UpperCAmelCase__				:					Tuple        =  False
       def 					snake_case_       (			self       )     ->		int:
          UpperCamelCase    :  List[Any]							=	ConvNextModelTester(self       )



