



'''simple docstring'''


import argparse

import requests
import torch
from PIL import Image
from torchvision.transforms import Compose, Normalize, Resize, ToTensor

from transformers import SwinaSRConfig, SwinaSRForImageSuperResolution, SwinaSRImageProcessor







def 				__lowerCamelCase				(   A__    )       ->	Tuple:






   """simple docstring"""
   UpperCamelCase					=  SwinaSRConfig()

   if "Swin2SR_ClassicalSR_X4_64" in checkpoint_url:
      UpperCamelCase					=  4
   elif "Swin2SR_CompressedSR_X4_48" in checkpoint_url:
      UpperCamelCase					=  4
      UpperCamelCase					=  48
      UpperCamelCase					=  'pixelshuffle_aux'
   elif "Swin2SR_Lightweight_X2_64" in checkpoint_url:
      UpperCamelCase					=  [6, 6, 6, 6]
      UpperCamelCase					=  60
      UpperCamelCase					=  [6, 6, 6, 6]
      UpperCamelCase					=  'pixelshuffledirect'
   elif "Swin2SR_RealworldSR_X4_64_BSRGAN_PSNR" in checkpoint_url:
      UpperCamelCase					=  4
      UpperCamelCase					=  'nearest+conv'
   elif "Swin2SR_Jpeg_dynamic" in checkpoint_url:
      UpperCamelCase					=  1
      UpperCamelCase					=  1
      UpperCamelCase					=  126
      UpperCamelCase					=  7
      UpperCamelCase					=  255.0
      UpperCamelCase					=  ''

   return config







def 				__lowerCamelCase				(   A__    ,						A__    )       ->	Optional[int]:






   """simple docstring"""
   if "patch_embed.proj" in name and "layers" not in name:
      UpperCamelCase					=  name.replace('patch_embed.proj'    ,						'embeddings.patch_embeddings.projection'    )
   if "patch_embed.norm" in name:
      UpperCamelCase					=  name.replace('patch_embed.norm'    ,						'embeddings.patch_embeddings.layernorm'    )
   if "layers" in name:
      UpperCamelCase					=  name.replace('layers'    ,						'encoder.stages'    )
   if "residual_group.blocks" in name:
      UpperCamelCase					=  name.replace('residual_group.blocks'    ,						'layers'    )
   if "attn.proj" in name:
      UpperCamelCase					=  name.replace('attn.proj'    ,						'attention.output.dense'    )
   if "attn" in name:
      UpperCamelCase					=  name.replace('attn'    ,						'attention.self'    )
   if "norm1" in name:
      UpperCamelCase					=  name.replace('norm1'    ,						'layernorm_before'    )
   if "norm2" in name:
      UpperCamelCase					=  name.replace('norm2'    ,						'layernorm_after'    )
   if "mlp.fc1" in name:
      UpperCamelCase					=  name.replace('mlp.fc1'    ,						'intermediate.dense'    )
   if "mlp.fc2" in name:
      UpperCamelCase					=  name.replace('mlp.fc2'    ,						'output.dense'    )
   if "q_bias" in name:
      UpperCamelCase					=  name.replace('q_bias'    ,						'query.bias'    )
   if "k_bias" in name:
      UpperCamelCase					=  name.replace('k_bias'    ,						'key.bias'    )
   if "v_bias" in name:
      UpperCamelCase					=  name.replace('v_bias'    ,						'value.bias'    )
   if "cpb_mlp" in name:
      UpperCamelCase					=  name.replace('cpb_mlp'    ,						'continuous_position_bias_mlp'    )
   if "patch_embed.proj" in name:
      UpperCamelCase					=  name.replace('patch_embed.proj'    ,						'patch_embed.projection'    )

   if name == "norm.weight":
      UpperCamelCase					=  'layernorm.weight'
   if name == "norm.bias":
      UpperCamelCase					=  'layernorm.bias'

   if "conv_first" in name:
      UpperCamelCase					=  name.replace('conv_first'    ,						'first_convolution'    )

   if (
       "upsample" in name
       or "conv_before_upsample" in name
       or "conv_bicubic" in name
       or "conv_up" in name
       or "conv_hr" in name
       or "conv_last" in name
       or "aux" in name
   ):
      # heads
      if "conv_last" in name:
         UpperCamelCase					=  name.replace('conv_last'    ,						'final_convolution'    )
      if config.upsampler in ["pixelshuffle", "pixelshuffle_aux", "nearest+conv"]:
         if "conv_before_upsample.0" in name:
            UpperCamelCase					=  name.replace('conv_before_upsample.0'    ,						'conv_before_upsample'    )
         if "upsample.0" in name:
            UpperCamelCase					=  name.replace('upsample.0'    ,						'upsample.convolution_0'    )
         if "upsample.2" in name:
            UpperCamelCase					=  name.replace('upsample.2'    ,						'upsample.convolution_1'    )
         UpperCamelCase					=  'upsample.' + name
      elif config.upsampler == "pixelshuffledirect":
         UpperCamelCase					=  name.replace('upsample.0.weight'    ,						'upsample.conv.weight'    )
         UpperCamelCase					=  name.replace('upsample.0.bias'    ,						'upsample.conv.bias'    )
      else:
         pass
   else:
      UpperCamelCase					=  'swin2sr.' + name

   return name







def 				__lowerCamelCase				(   A__    ,						A__    )       ->	List[Any]:






   """simple docstring"""
   for key in orig_state_dict.copy().keys():
      UpperCamelCase					=  orig_state_dict.pop(A__    )

      if "qkv" in key:
         UpperCamelCase					=  key.split('.'    )
         UpperCamelCase					=  int(key_split[1]    )
         UpperCamelCase					=  int(key_split[4]    )
         UpperCamelCase					=  config.embed_dim

         if "weight" in key:
            UpperCamelCase					=  val[:dim, :]
            UpperCamelCase					=  val[dim : dim * 2, :]
            UpperCamelCase					=  val[-dim:, :]
         else:
            UpperCamelCase					=  val[:dim]
            UpperCamelCase					=  val[dim : dim * 2]
            UpperCamelCase					=  val[-dim:]
         pass
      else:
         UpperCamelCase					=  val

   return orig_state_dict







def 				__lowerCamelCase				(   A__    ,						A__    ,						A__    )       ->	Union[str, Any]:






   """simple docstring"""
   UpperCamelCase					=  get_config(A__    )
   UpperCamelCase					=  SwinaSRForImageSuperResolution(A__    )
   model.eval()

   UpperCamelCase					=  torch.hub.load_state_dict_from_url(A__    ,						map_location='cpu'    )
   UpperCamelCase					=  convert_state_dict(A__    ,						A__    )
   UpperCamelCase				,      UpperCamelCase					=  model.load_state_dict(A__    ,						strict=A__    )

   if len(A__    ) > 0:
      raise ValueError('Missing keys when converting: {}'.format(A__    )    )
   for key in unexpected_keys:
      if not ("relative_position_index" in key or "relative_coords_table" in key or "self_mask" in key):
         raise ValueError(F"""Unexpected key {key} in state_dict"""    )

    # verify values
   UpperCamelCase					=  'https://github.com/mv-lab/swin2sr/blob/main/testsets/real-inputs/shanghai.jpg?raw=true'
   UpperCamelCase					=  Image.open(requests.get(A__    ,						stream=A__    ).raw    ).convert('RGB'    )
   UpperCamelCase					=  SwinaSRImageProcessor()
   # pixel_values = processor(image, return_tensors="pt").pixel_values

   UpperCamelCase					=  126 if 'Jpeg' in checkpoint_url else 256
   UpperCamelCase					=  Compose(
       [
           Resize((image_size, image_size)    ),
           ToTensor(),
           Normalize(mean=[0.485, 0.456, 0.406]    ,						std=[0.229, 0.224, 0.225]    ),
       ]    )
   UpperCamelCase					=  transforms(A__    ).unsqueeze(0    )

   if config.num_channels == 1:
      UpperCamelCase					=  pixel_values[:, 0, :, :].unsqueeze(1    )

   UpperCamelCase					=  model(A__    )

   # assert values
   if "Swin2SR_ClassicalSR_X2_64" in checkpoint_url:
      UpperCamelCase					=  torch.Size([1, 3, 512, 512]    )
      UpperCamelCase					=  torch.tensor(
          [[-0.7_087, -0.7_138, -0.6_721], [-0.8_340, -0.8_095, -0.7_298], [-0.9_149, -0.8_414, -0.7_940]]    )
   elif "Swin2SR_ClassicalSR_X4_64" in checkpoint_url:
      UpperCamelCase					=  torch.Size([1, 3, 1_024, 1_024]    )
      UpperCamelCase					=  torch.tensor(
          [[-0.7_775, -0.8_105, -0.8_933], [-0.7_764, -0.8_356, -0.9_225], [-0.7_976, -0.8_686, -0.9_579]]    )
   elif "Swin2SR_CompressedSR_X4_48" in checkpoint_url:
      # TODO values didn't match exactly here
      UpperCamelCase					=  torch.Size([1, 3, 1_024, 1_024]    )
      UpperCamelCase					=  torch.tensor(
          [[-0.8_035, -0.7_504, -0.7_491], [-0.8_538, -0.8_124, -0.7_782], [-0.8_804, -0.8_651, -0.8_493]]    )
   elif "Swin2SR_Lightweight_X2_64" in checkpoint_url:
      UpperCamelCase					=  torch.Size([1, 3, 512, 512]    )
      UpperCamelCase					=  torch.tensor(
          [[-0.7_669, -0.8_662, -0.8_767], [-0.8_810, -0.9_962, -0.9_820], [-0.9_340, -1.0_322, -1.1_149]]    )
   elif "Swin2SR_RealworldSR_X4_64_BSRGAN_PSNR" in checkpoint_url:
      UpperCamelCase					=  torch.Size([1, 3, 1_024, 1_024]    )
      UpperCamelCase					=  torch.tensor(
          [[-0.5_238, -0.5_557, -0.6_321], [-0.6_016, -0.5_903, -0.6_391], [-0.6_244, -0.6_334, -0.6_889]]    )

   assert (
       outputs.reconstruction.shape == expected_shape
   ), F"""Shape of reconstruction should be {expected_shape}, but is {outputs.reconstruction.shape}"""
   assert torch.allclose(outputs.reconstruction[0, 0, :3, :3]    ,						A__    ,						atol=1e-3    )
   print('Looks ok!'    )

   UpperCamelCase					=  {
       'https://github.com/mv-lab/swin2sr/releases/download/v0.0.1/Swin2SR_ClassicalSR_X2_64.pth': (
           'swin2SR-classical-sr-x2-64'
       ),
       'https://github.com/mv-lab/swin2sr/releases/download/v0.0.1/Swin2SR_ClassicalSR_X4_64.pth': (
           'swin2SR-classical-sr-x4-64'
       ),
       'https://github.com/mv-lab/swin2sr/releases/download/v0.0.1/Swin2SR_CompressedSR_X4_48.pth': (
           'swin2SR-compressed-sr-x4-48'
       ),
       'https://github.com/mv-lab/swin2sr/releases/download/v0.0.1/Swin2SR_Lightweight_X2_64.pth': (
           'swin2SR-lightweight-x2-64'
       ),
       'https://github.com/mv-lab/swin2sr/releases/download/v0.0.1/Swin2SR_RealworldSR_X4_64_BSRGAN_PSNR.pth': (
           'swin2SR-realworld-sr-x4-64-bsrgan-psnr'
       ),
   }
   UpperCamelCase					=  url_to_name[checkpoint_url]

   if pytorch_dump_folder_path is not None:
      print(F"""Saving model {model_name} to {pytorch_dump_folder_path}"""    )
      model.save_pretrained(A__    )
      print(F"""Saving image processor to {pytorch_dump_folder_path}"""    )
      processor.save_pretrained(A__    )

   if push_to_hub:
      model.push_to_hub(F"""caidas/{model_name}"""    )
      processor.push_to_hub(F"""caidas/{model_name}"""    )


if __name__ == "__main__":
   _lowerCamelCase	:       Dict      	=	argparse.ArgumentParser()
   # Required parameters
   parser.add_argument(
       "--checkpoint_url",
       default="https://github.com/mv-lab/swin2sr/releases/download/v0.0.1/Swin2SR_ClassicalSR_X2_64.pth",
       type=str,
       help="URL of the original Swin2SR checkpoint you'd like to convert.",
   )
   parser.add_argument(
       "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
   )
   parser.add_argument("--push_to_hub", action="store_true", help="Whether to push the converted model to the hub.")

   _lowerCamelCase	:       List[str]      	=	parser.parse_args()
   convert_swinasr_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub)






'''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  SCREAMING_SNAKE_CASE :






    """simple docstring"""





    def __init__(  self      :					Optional[int]  ,						UpperCamelCase__      :					List[str]  ,						UpperCamelCase__      :					Any=1_3  ,						UpperCamelCase__      :					Optional[int]=3_2  ,						UpperCamelCase__      :					Any=3  ,						UpperCamelCase__      :					Tuple=4  ,						UpperCamelCase__      :					str=[1_0, 2_0, 3_0, 4_0]  ,						UpperCamelCase__      :					str=[2, 2, 3, 2]  ,						UpperCamelCase__      :					Dict=True  ,						UpperCamelCase__      :					List[str]=True  ,						UpperCamelCase__      :					str=3_7  ,						UpperCamelCase__      :					Union[str, Any]="gelu"  ,						UpperCamelCase__      :					Dict=1_0  ,						UpperCamelCase__      :					Union[str, Any]=0.0_2  ,						UpperCamelCase__      :					int=["stage2", "stage3", "stage4"]  ,						UpperCamelCase__      :					List[str]=[2, 3, 4]  ,						UpperCamelCase__      :					Any=None  ,						):


       """simple docstring"""







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






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


       """simple docstring"""







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

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

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






    def  A       (  self      :					List[str] ):


       """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=UpperCamelCase__  ,						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]  ,						UpperCamelCase__      :					List[Any]  ,						UpperCamelCase__      :					Any  ,						UpperCamelCase__      :					str ):


       """simple docstring"""







       UpperCamelCase					=  ConvNextModel(config=UpperCamelCase__ )
       model.to(UpperCamelCase__ )
       model.eval()
       UpperCamelCase					=  model(UpperCamelCase__ )
       # 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      :					List[str]  ,						UpperCamelCase__      :					Union[str, Any]  ,						UpperCamelCase__      :					Optional[Any]  ,						UpperCamelCase__      :					int ):


       """simple docstring"""







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






    def  A       (  self      :					Tuple  ,						UpperCamelCase__      :					Optional[int]  ,						UpperCamelCase__      :					Tuple  ,						UpperCamelCase__      :					str ):


       """simple docstring"""







       UpperCamelCase					=  ConvNextBackbone(config=UpperCamelCase__ )
       model.to(UpperCamelCase__ )
       model.eval()
       UpperCamelCase					=  model(UpperCamelCase__ )

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

       # 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      :					Any ):


       """simple docstring"""







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

@require_torch
class  SCREAMING_SNAKE_CASE (  _a   ,						_a   ,						unittest.TestCase		):






    """simple docstring"""





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

    _SCREAMING_SNAKE_CASE	  =  True
    _SCREAMING_SNAKE_CASE	  =  False
    _SCREAMING_SNAKE_CASE	  =  False
    _SCREAMING_SNAKE_CASE	  =  False
    _SCREAMING_SNAKE_CASE	  =  False






    def  A       (  self      :					Tuple ):


       """simple docstring"""







       UpperCamelCase					=  ConvNextModelTester(self )
       UpperCamelCase					=  ConfigTester(self  ,						config_class=UpperCamelCase__  ,						has_text_modality=UpperCamelCase__  ,						hidden_size=3_7 )






    def  A       (  self      :					List[str] ):


       """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      :					Optional[int] ):


       """simple docstring"""







       return






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


       """simple docstring"""







       pass






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


       """simple docstring"""







       pass






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


       """simple docstring"""







       pass






    def  A       (  self      :					Any ):


       """simple docstring"""







       UpperCamelCase				,      UpperCamelCase					=  self.model_tester.prepare_config_and_inputs_for_common()

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

          UpperCamelCase					=  ['pixel_values']
          self.assertListEqual(arg_names[:1]  ,						UpperCamelCase__ )






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


       """simple docstring"""







       UpperCamelCase					=  self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*UpperCamelCase__ )






    def  A       (  self      :					Tuple ):


       """simple docstring"""







       UpperCamelCase					=  self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_backbone(*UpperCamelCase__ )






    def  A       (  self      :					Optional[Any] ):


       """simple docstring"""







       def check_hidden_states_output(UpperCamelCase__      :					Dict  ,						UpperCamelCase__      :					Union[str, Any]  ,						UpperCamelCase__      :					Tuple ):
          UpperCamelCase					=  model_class(UpperCamelCase__ )
          model.to(UpperCamelCase__ )
          model.eval()

          with torch.no_grad():
             UpperCamelCase					=  model(**self._prepare_for_class(UpperCamelCase__  ,						UpperCamelCase__ ) )

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

          UpperCamelCase					=  self.model_tester.num_stages
          self.assertEqual(len(UpperCamelCase__ )  ,						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					=  self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
          UpperCamelCase					=  True
          check_hidden_states_output(UpperCamelCase__  ,						UpperCamelCase__  ,						UpperCamelCase__ )

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

          check_hidden_states_output(UpperCamelCase__  ,						UpperCamelCase__  ,						UpperCamelCase__ )






    def  A       (  self      :					Dict ):


       """simple docstring"""







       UpperCamelCase					=  self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*UpperCamelCase__ )






    @slow
    def  A       (  self      :					Dict ):


       """simple docstring"""







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







def 				__lowerCamelCase				(   )       ->	Any:






   """simple docstring"""
   UpperCamelCase					=  Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'    )
   return image

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






    """simple docstring"""





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


       """simple docstring"""







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






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


       """simple docstring"""







       UpperCamelCase					=  ConvNextForImageClassification.from_pretrained('facebook/convnext-tiny-224' ).to(UpperCamelCase__ )

       UpperCamelCase					=  self.default_image_processor
       UpperCamelCase					=  prepare_img()
       UpperCamelCase					=  image_processor(images=UpperCamelCase__  ,						return_tensors='pt' ).to(UpperCamelCase__ )

       # forward pass
       with torch.no_grad():
          UpperCamelCase					=  model(**UpperCamelCase__ )

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

       UpperCamelCase					=  torch.tensor([-0.0_2_6_0, -0.4_7_3_9, 0.1_9_1_1] ).to(UpperCamelCase__ )

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

@require_torch
class  SCREAMING_SNAKE_CASE (  unittest.TestCase   ,						_a		):






    """simple docstring"""





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

    _SCREAMING_SNAKE_CASE	  =  False






    def  A       (  self      :					Tuple ):


       """simple docstring"""







       UpperCamelCase					=  ConvNextModelTester(self )

