
"""simple docstring"""




import collections
import inspect
import unittest

from transformers import SwinvaConfig
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, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
						import torch
						from torch import nn

						from transformers import SwinvaForImageClassification, SwinvaForMaskedImageModeling, SwinvaModel
						from transformers.models.swinva.modeling_swinva import SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
						from PIL import Image

						from transformers import AutoImageProcessor





class  snake_case     :

							def __init__(self       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_=13       ,       SCREAMING_SNAKE_CASE_=32       ,       SCREAMING_SNAKE_CASE_=2       ,       SCREAMING_SNAKE_CASE_=3       ,       SCREAMING_SNAKE_CASE_=16       ,       SCREAMING_SNAKE_CASE_=[1, 2, 1]       ,       SCREAMING_SNAKE_CASE_=[2, 2, 4]       ,       SCREAMING_SNAKE_CASE_=2       ,       SCREAMING_SNAKE_CASE_=2.0       ,       SCREAMING_SNAKE_CASE_=True       ,       SCREAMING_SNAKE_CASE_=0.0       ,       SCREAMING_SNAKE_CASE_=0.0       ,       SCREAMING_SNAKE_CASE_=0.1       ,       SCREAMING_SNAKE_CASE_="gelu"       ,       SCREAMING_SNAKE_CASE_=False       ,       SCREAMING_SNAKE_CASE_=True       ,       SCREAMING_SNAKE_CASE_=0.02       ,       SCREAMING_SNAKE_CASE_=1e-5       ,       SCREAMING_SNAKE_CASE_=True       ,       SCREAMING_SNAKE_CASE_=None       ,       SCREAMING_SNAKE_CASE_=True       ,       SCREAMING_SNAKE_CASE_=10       ,       SCREAMING_SNAKE_CASE_=8       ,       ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = parent
									SCREAMING_SNAKE_CASE_						 = batch_size
									SCREAMING_SNAKE_CASE_						 = image_size
									SCREAMING_SNAKE_CASE_						 = patch_size
									SCREAMING_SNAKE_CASE_						 = num_channels
									SCREAMING_SNAKE_CASE_						 = embed_dim
									SCREAMING_SNAKE_CASE_						 = depths
									SCREAMING_SNAKE_CASE_						 = num_heads
									SCREAMING_SNAKE_CASE_						 = window_size
									SCREAMING_SNAKE_CASE_						 = mlp_ratio
									SCREAMING_SNAKE_CASE_						 = qkv_bias
									SCREAMING_SNAKE_CASE_						 = hidden_dropout_prob
									SCREAMING_SNAKE_CASE_						 = attention_probs_dropout_prob
									SCREAMING_SNAKE_CASE_						 = drop_path_rate
									SCREAMING_SNAKE_CASE_						 = hidden_act
									SCREAMING_SNAKE_CASE_						 = use_absolute_embeddings
									SCREAMING_SNAKE_CASE_						 = patch_norm
									SCREAMING_SNAKE_CASE_						 = layer_norm_eps
									SCREAMING_SNAKE_CASE_						 = initializer_range
									SCREAMING_SNAKE_CASE_						 = is_training
									SCREAMING_SNAKE_CASE_						 = scope
									SCREAMING_SNAKE_CASE_						 = use_labels
									SCREAMING_SNAKE_CASE_						 = type_sequence_label_size
									SCREAMING_SNAKE_CASE_						 = encoder_stride

							def _lowercase					(self    ):

									"""simple docstring"""







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

									SCREAMING_SNAKE_CASE_						 = None
									if self.use_labels:
											SCREAMING_SNAKE_CASE_						 = ids_tensor([self.batch_size]       ,       self.type_sequence_label_size    )

									SCREAMING_SNAKE_CASE_						 = self.get_config()

									return config, pixel_values, labels

							def _lowercase					(self    ):

									"""simple docstring"""







									return SwinvaConfig(
									    image_size=self.image_size       ,       patch_size=self.patch_size       ,       num_channels=self.num_channels       ,       embed_dim=self.embed_dim       ,       depths=self.depths       ,       num_heads=self.num_heads       ,       window_size=self.window_size       ,       mlp_ratio=self.mlp_ratio       ,       qkv_bias=self.qkv_bias       ,       hidden_dropout_prob=self.hidden_dropout_prob       ,       attention_probs_dropout_prob=self.attention_probs_dropout_prob       ,       drop_path_rate=self.drop_path_rate       ,       hidden_act=self.hidden_act       ,       use_absolute_embeddings=self.use_absolute_embeddings       ,       path_norm=self.patch_norm       ,       layer_norm_eps=self.layer_norm_eps       ,       initializer_range=self.initializer_range       ,       encoder_stride=self.encoder_stride       ,       )

							def _lowercase					(self       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = SwinvaModel(config=SCREAMING_SNAKE_CASE_    )
									model.to(SCREAMING_SNAKE_CASE_    )
									model.eval()
									SCREAMING_SNAKE_CASE_						 = model(SCREAMING_SNAKE_CASE_    )

									SCREAMING_SNAKE_CASE_						 = ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths    ) - 1))
									SCREAMING_SNAKE_CASE_						 = int(config.embed_dim * 2 ** (len(config.depths    ) - 1)    )

									self.parent.assertEqual(result.last_hidden_state.shape       ,       (self.batch_size, expected_seq_len, expected_dim)    )

							def _lowercase					(self       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = SwinvaForMaskedImageModeling(config=SCREAMING_SNAKE_CASE_    )
									model.to(SCREAMING_SNAKE_CASE_    )
									model.eval()
									SCREAMING_SNAKE_CASE_						 = model(SCREAMING_SNAKE_CASE_    )
									self.parent.assertEqual(
									    result.logits.shape       ,       (self.batch_size, self.num_channels, self.image_size, self.image_size)    )

									# test greyscale images
									SCREAMING_SNAKE_CASE_						 = 1
									SCREAMING_SNAKE_CASE_						 = SwinvaForMaskedImageModeling(SCREAMING_SNAKE_CASE_    )
									model.to(SCREAMING_SNAKE_CASE_    )
									model.eval()

									SCREAMING_SNAKE_CASE_						 = floats_tensor([self.batch_size, 1, self.image_size, self.image_size]    )
									SCREAMING_SNAKE_CASE_						 = model(SCREAMING_SNAKE_CASE_    )
									self.parent.assertEqual(result.logits.shape       ,       (self.batch_size, 1, self.image_size, self.image_size)    )

							def _lowercase					(self       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = self.type_sequence_label_size
									SCREAMING_SNAKE_CASE_						 = SwinvaForImageClassification(SCREAMING_SNAKE_CASE_    )
									model.to(SCREAMING_SNAKE_CASE_    )
									model.eval()
									SCREAMING_SNAKE_CASE_						 = model(SCREAMING_SNAKE_CASE_       ,       labels=SCREAMING_SNAKE_CASE_    )
									self.parent.assertEqual(result.logits.shape       ,       (self.batch_size, self.type_sequence_label_size)    )







							def _lowercase					(self    ):

									"""simple docstring"""







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







@require_torch
class  snake_case     (							__lowercase       ,			__lowercase       ,			unittest.TestCase   ):
							UpperCAmelCase__						     =      (
							    (SwinvaModel, SwinvaForImageClassification, SwinvaForMaskedImageModeling) if is_torch_available() else ()
							)
							UpperCAmelCase__						     =      (
							    {'''feature-extraction''': SwinvaModel, '''image-classification''': SwinvaForImageClassification}
							    if is_torch_available()
							    else {}
							)

							UpperCAmelCase__						     =      False
							UpperCAmelCase__						     =      False
							UpperCAmelCase__						     =      False
							UpperCAmelCase__						     =      False

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = SwinvaModelTester(self    )
									SCREAMING_SNAKE_CASE_						 = ConfigTester(self       ,       config_class=SCREAMING_SNAKE_CASE_       ,       embed_dim=37    )

							def _lowercase					(self    ):

									"""simple docstring"""







									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 _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_    )

							@unittest.skip(reason='''Got `CUDA error: misaligned address` with PyTorch 2.0.0.'''    )
							def _lowercase					(self    ):

									"""simple docstring"""







									pass

							@unittest.skip(reason='''Swinv2 does not use inputs_embeds'''    )
							def _lowercase					(self    ):

									"""simple docstring"""







									pass

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_						 = self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
											SCREAMING_SNAKE_CASE_						 = model_class(SCREAMING_SNAKE_CASE_    )
											self.assertIsInstance(model.get_input_embeddings()       ,       (nn.Module)    )
											SCREAMING_SNAKE_CASE_						 = model.get_output_embeddings()
											self.assertTrue(x is None or isinstance(SCREAMING_SNAKE_CASE_       ,       nn.Linear    )    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_						 = self.model_tester.prepare_config_and_inputs_for_common()

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

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

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_						 = self.model_tester.prepare_config_and_inputs_for_common()
									SCREAMING_SNAKE_CASE_						 = True

									for model_class in self.all_model_classes:
											SCREAMING_SNAKE_CASE_						 = True
											SCREAMING_SNAKE_CASE_						 = False
											SCREAMING_SNAKE_CASE_						 = True
											SCREAMING_SNAKE_CASE_						 = model_class(SCREAMING_SNAKE_CASE_    )
											model.to(SCREAMING_SNAKE_CASE_    )
											model.eval()
											with torch.no_grad():
													SCREAMING_SNAKE_CASE_						 = model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )    )
											SCREAMING_SNAKE_CASE_						 = outputs.attentions
											SCREAMING_SNAKE_CASE_						 = len(self.model_tester.depths    )
											self.assertEqual(len(SCREAMING_SNAKE_CASE_    )       ,       SCREAMING_SNAKE_CASE_    )

											# check that output_attentions also work using config
											del inputs_dict["output_attentions"]
											SCREAMING_SNAKE_CASE_						 = True
											SCREAMING_SNAKE_CASE_						 = config.window_size**2
											SCREAMING_SNAKE_CASE_						 = model_class(SCREAMING_SNAKE_CASE_    )
											model.to(SCREAMING_SNAKE_CASE_    )
											model.eval()
											with torch.no_grad():
													SCREAMING_SNAKE_CASE_						 = model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )    )
											SCREAMING_SNAKE_CASE_						 = outputs.attentions
											self.assertEqual(len(SCREAMING_SNAKE_CASE_    )       ,       SCREAMING_SNAKE_CASE_    )

											self.assertListEqual(
											    list(attentions[0].shape[-3:]    )       ,       [self.model_tester.num_heads[0], window_size_squared, window_size_squared]       ,       )
											SCREAMING_SNAKE_CASE_						 = len(SCREAMING_SNAKE_CASE_    )

											# Check attention is always last and order is fine
											SCREAMING_SNAKE_CASE_						 = True
											SCREAMING_SNAKE_CASE_						 = True
											SCREAMING_SNAKE_CASE_						 = model_class(SCREAMING_SNAKE_CASE_    )
											model.to(SCREAMING_SNAKE_CASE_    )
											model.eval()
											with torch.no_grad():
													SCREAMING_SNAKE_CASE_						 = model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )    )

											if hasattr(self.model_tester       ,       '''num_hidden_states_types'''    ):
													SCREAMING_SNAKE_CASE_						 = self.model_tester.num_hidden_states_types
											else:
													# also another +1 for reshaped_hidden_states
													SCREAMING_SNAKE_CASE_						 = 2
											self.assertEqual(out_len + added_hidden_states       ,       len(SCREAMING_SNAKE_CASE_    )    )

											SCREAMING_SNAKE_CASE_						 = outputs.attentions

											self.assertEqual(len(SCREAMING_SNAKE_CASE_    )       ,       SCREAMING_SNAKE_CASE_    )

											self.assertListEqual(
											    list(self_attentions[0].shape[-3:]    )       ,       [self.model_tester.num_heads[0], window_size_squared, window_size_squared]       ,       )

							def _lowercase					(self       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = model_class(SCREAMING_SNAKE_CASE_    )
									model.to(SCREAMING_SNAKE_CASE_    )
									model.eval()

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

									SCREAMING_SNAKE_CASE_						 = outputs.hidden_states

									SCREAMING_SNAKE_CASE_						 = getattr(
									    self.model_tester       ,       '''expected_num_hidden_layers'''       ,       len(self.model_tester.depths    ) + 1    )
									self.assertEqual(len(SCREAMING_SNAKE_CASE_    )       ,       SCREAMING_SNAKE_CASE_    )

									# Swinv2 has a different seq_length
									SCREAMING_SNAKE_CASE_						 = (
									    config.patch_size
									    if isinstance(config.patch_size       ,       collections.abc.Iterable    )
									    else (config.patch_size, config.patch_size)
									)

									SCREAMING_SNAKE_CASE_						 = (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

									self.assertListEqual(
									    list(hidden_states[0].shape[-2:]    )       ,       [num_patches, self.model_tester.embed_dim]       ,       )

									SCREAMING_SNAKE_CASE_						 = outputs.reshaped_hidden_states
									self.assertEqual(len(SCREAMING_SNAKE_CASE_    )       ,       SCREAMING_SNAKE_CASE_    )

									SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_						 = reshaped_hidden_states[0].shape
									SCREAMING_SNAKE_CASE_						 = (
									    reshaped_hidden_states[0].view(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       height * width    ).permute(0       ,       2       ,       1    )
									)
									self.assertListEqual(
									    list(reshaped_hidden_states.shape[-2:]    )       ,       [num_patches, self.model_tester.embed_dim]       ,       )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_						 = self.model_tester.prepare_config_and_inputs_for_common()

									SCREAMING_SNAKE_CASE_						 = (
									    self.model_tester.image_size
									    if isinstance(self.model_tester.image_size       ,       collections.abc.Iterable    )
									    else (self.model_tester.image_size, self.model_tester.image_size)
									)

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

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

											self.check_hidden_states_output(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_						 = self.model_tester.prepare_config_and_inputs_for_common()
									SCREAMING_SNAKE_CASE_						 = 3

									SCREAMING_SNAKE_CASE_						 = (
									    self.model_tester.image_size
									    if isinstance(self.model_tester.image_size       ,       collections.abc.Iterable    )
									    else (self.model_tester.image_size, self.model_tester.image_size)
									)
									SCREAMING_SNAKE_CASE_						 = (
									    config.patch_size
									    if isinstance(config.patch_size       ,       collections.abc.Iterable    )
									    else (config.patch_size, config.patch_size)
									)

									SCREAMING_SNAKE_CASE_						 = image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
									SCREAMING_SNAKE_CASE_						 = image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

									for model_class in self.all_model_classes:
											SCREAMING_SNAKE_CASE_						 = True
											self.check_hidden_states_output(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       (padded_height, padded_width)    )

											# check that output_hidden_states also work using config
											del inputs_dict["output_hidden_states"]
											SCREAMING_SNAKE_CASE_						 = True
											self.check_hidden_states_output(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       (padded_height, padded_width)    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_masked_image_modeling(*SCREAMING_SNAKE_CASE_    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE_    )

							@slow
							def _lowercase					(self    ):

									"""simple docstring"""







									for model_name in SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											SCREAMING_SNAKE_CASE_						 = SwinvaModel.from_pretrained(SCREAMING_SNAKE_CASE_    )
											self.assertIsNotNone(SCREAMING_SNAKE_CASE_    )







							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_						 = self.model_tester.prepare_config_and_inputs_for_common()

									SCREAMING_SNAKE_CASE_						 = _config_zero_init(SCREAMING_SNAKE_CASE_    )
									for model_class in self.all_model_classes:
											SCREAMING_SNAKE_CASE_						 = model_class(config=SCREAMING_SNAKE_CASE_    )
											for name, param in model.named_parameters():
													if "embeddings" not in name and "logit_scale" not in name and param.requires_grad:
															self.assertIn(
															    ((param.data.mean() * 1e9).round() / 1e9).item()       ,       [0.0, 1.0]       ,       msg=f'Parameter {name} of model {model_class} seems not properly initialized'       ,       )







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

							@cached_property
							def _lowercase					(self    ):

									"""simple docstring"""







									return (
									    AutoImageProcessor.from_pretrained('''microsoft/swinv2-tiny-patch4-window8-256'''    )
									    if is_vision_available()
									    else None
									)







							@slow
							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = SwinvaForImageClassification.from_pretrained('''microsoft/swinv2-tiny-patch4-window8-256'''    ).to(
									    SCREAMING_SNAKE_CASE_    )
									SCREAMING_SNAKE_CASE_						 = self.default_image_processor

									SCREAMING_SNAKE_CASE_						 = Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''    )
									SCREAMING_SNAKE_CASE_						 = image_processor(images=SCREAMING_SNAKE_CASE_       ,       return_tensors='''pt'''    ).to(SCREAMING_SNAKE_CASE_    )

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

									# verify the logits
									SCREAMING_SNAKE_CASE_						 = torch.Size((1, 10_00)    )
									self.assertEqual(outputs.logits.shape       ,       SCREAMING_SNAKE_CASE_    )
									SCREAMING_SNAKE_CASE_						 = torch.tensor([-0.39_47, -0.43_06, 0.00_26]    ).to(SCREAMING_SNAKE_CASE_    )
									self.assertTrue(torch.allclose(outputs.logits[0, :3]       ,       SCREAMING_SNAKE_CASE_       ,       atol=1e-4    )    )

"""simple docstring"""




import argparse
import json

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from torchvision import transforms

from transformers import BitImageProcessor, FocalNetConfig, FocalNetForImageClassification
from transformers.image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, PILImageResampling



def        _lowerCamelCase ( __a    ):
		SCREAMING_SNAKE_CASE_						 = [2, 2, 6, 2] if '''tiny''' in model_name else [2, 2, 18, 2]
		SCREAMING_SNAKE_CASE_						 = True if '''large''' in model_name or '''huge''' in model_name else False
		SCREAMING_SNAKE_CASE_						 = True if '''large''' in model_name or '''huge''' in model_name else False
		SCREAMING_SNAKE_CASE_						 = True if '''large''' in model_name or '''huge''' in model_name else False

		if "large" in model_name or "xlarge" in model_name or "huge" in model_name:
				if "fl3" in model_name:
						SCREAMING_SNAKE_CASE_						 = [3, 3, 3, 3]
						SCREAMING_SNAKE_CASE_						 = [5, 5, 5, 5]
				elif "fl4" in model_name:
						SCREAMING_SNAKE_CASE_						 = [4, 4, 4, 4]
						SCREAMING_SNAKE_CASE_						 = [3, 3, 3, 3]

		if "tiny" in model_name or "small" in model_name or "base" in model_name:
				SCREAMING_SNAKE_CASE_						 = [3, 3, 3, 3]
				if "lrf" in model_name:
						SCREAMING_SNAKE_CASE_						 = [3, 3, 3, 3]
				else:
						SCREAMING_SNAKE_CASE_						 = [2, 2, 2, 2]

		if "tiny" in model_name:
				SCREAMING_SNAKE_CASE_						 = 96
		elif "small" in model_name:
				SCREAMING_SNAKE_CASE_						 = 96
		elif "base" in model_name:
				SCREAMING_SNAKE_CASE_						 = 128
		elif "large" in model_name:
				SCREAMING_SNAKE_CASE_						 = 192
		elif "xlarge" in model_name:
				SCREAMING_SNAKE_CASE_						 = 256
		elif "huge" in model_name:
				SCREAMING_SNAKE_CASE_						 = 352

		# set label information
		SCREAMING_SNAKE_CASE_						 = '''huggingface/label-files'''
		if "large" in model_name or "huge" in model_name:
				SCREAMING_SNAKE_CASE_						 = '''imagenet-22k-id2label.json'''
		else:
				SCREAMING_SNAKE_CASE_						 = '''imagenet-1k-id2label.json'''

		SCREAMING_SNAKE_CASE_						 = json.load(open(hf_hub_download(__a,							__a,							repo_type='''dataset'''    ),							'''r'''    )    )
		SCREAMING_SNAKE_CASE_						 = {int(__a    ): v for k, v in idalabel.items()}
		SCREAMING_SNAKE_CASE_						 = {v: k for k, v in idalabel.items()}

		SCREAMING_SNAKE_CASE_						 = FocalNetConfig(
		    embed_dim=__a,							depths=__a,							focal_levels=__a,							focal_windows=__a,							use_conv_embed=__a,							idalabel=__a,							labelaid=__a,							use_post_layernorm=__a,							use_layerscale=__a,							)

		return config



def        _lowerCamelCase ( __a    ):
		if "patch_embed.proj" in name:
				SCREAMING_SNAKE_CASE_						 = name.replace('''patch_embed.proj''',							'''embeddings.patch_embeddings.projection'''    )
		if "patch_embed.norm" in name:
				SCREAMING_SNAKE_CASE_						 = name.replace('''patch_embed.norm''',							'''embeddings.norm'''    )
		if "layers" in name:
				SCREAMING_SNAKE_CASE_						 = '''encoder.''' + name
		if "encoder.layers" in name:
				SCREAMING_SNAKE_CASE_						 = name.replace('''encoder.layers''',							'''encoder.stages'''    )
		if "downsample.proj" in name:
				SCREAMING_SNAKE_CASE_						 = name.replace('''downsample.proj''',							'''downsample.projection'''    )
		if "blocks" in name:
				SCREAMING_SNAKE_CASE_						 = name.replace('''blocks''',							'''layers'''    )
		if "modulation.f.weight" in name or "modulation.f.bias" in name:
				SCREAMING_SNAKE_CASE_						 = name.replace('''modulation.f''',							'''modulation.projection_in'''    )
		if "modulation.h.weight" in name or "modulation.h.bias" in name:
				SCREAMING_SNAKE_CASE_						 = name.replace('''modulation.h''',							'''modulation.projection_context'''    )
		if "modulation.proj.weight" in name or "modulation.proj.bias" in name:
				SCREAMING_SNAKE_CASE_						 = name.replace('''modulation.proj''',							'''modulation.projection_out'''    )

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

		if "head" in name:
				SCREAMING_SNAKE_CASE_						 = name.replace('''head''',							'''classifier'''    )
		else:
				SCREAMING_SNAKE_CASE_						 = '''focalnet.''' + name

		return name



def        _lowerCamelCase ( __a,							__a,							__a=False    ):
		# fmt: off
		SCREAMING_SNAKE_CASE_						 = {
		    '''focalnet-tiny''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_tiny_srf.pth''',
		    '''focalnet-tiny-lrf''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_tiny_lrf.pth''',
		    '''focalnet-small''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_small_srf.pth''',
		    '''focalnet-small-lrf''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_small_lrf.pth''',
		    '''focalnet-base''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_base_srf.pth''',
		    '''focalnet-base-lrf''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_base_lrf.pth''',
		    '''focalnet-large-lrf-fl3''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_large_lrf_384.pth''',
		    '''focalnet-large-lrf-fl4''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_large_lrf_384_fl4.pth''',
		    '''focalnet-xlarge-lrf-fl3''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_xlarge_lrf_384.pth''',
		    '''focalnet-xlarge-lrf-fl4''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_xlarge_lrf_384_fl4.pth''',
		}
		# fmt: on

		SCREAMING_SNAKE_CASE_						 = model_name_to_url[model_name]
		print('''Checkpoint URL: ''',							__a    )
		SCREAMING_SNAKE_CASE_						 = torch.hub.load_state_dict_from_url(__a,							map_location='''cpu'''    )['''model''']

		# rename keys
		for key in state_dict.copy().keys():
				SCREAMING_SNAKE_CASE_						 = state_dict.pop(__a    )
				SCREAMING_SNAKE_CASE_						 = val

		SCREAMING_SNAKE_CASE_						 = get_focalnet_config(__a    )
		SCREAMING_SNAKE_CASE_						 = FocalNetForImageClassification(__a    )
		model.eval()

		# load state dict
		model.load_state_dict(__a    )

		# verify conversion
		SCREAMING_SNAKE_CASE_						 = '''http://images.cocodataset.org/val2017/000000039769.jpg'''

		SCREAMING_SNAKE_CASE_						 = BitImageProcessor(
		    do_resize=__a,							size={'''shortest_edge''': 256},							resample=PILImageResampling.BILINEAR,							do_center_crop=__a,							crop_size=224,							do_normalize=__a,							image_mean=__a,							image_std=__a,							)
		SCREAMING_SNAKE_CASE_						 = Image.open(requests.get(__a,							stream=__a    ).raw    )
		SCREAMING_SNAKE_CASE_						 = processor(images=__a,							return_tensors='''pt'''    )

		SCREAMING_SNAKE_CASE_						 = transforms.Compose(
		    [
		        transforms.Resize(256    ),
		        transforms.CenterCrop(224    ),
		        transforms.ToTensor(),
		        transforms.Normalize(mean=[0.4_8_5, 0.4_5_6, 0.4_0_6],							std=[0.2_2_9, 0.2_2_4, 0.2_2_5]    ),
		    ]    )

		SCREAMING_SNAKE_CASE_						 = image_transforms(__a    ).unsqueeze(0    )

		# verify pixel_values
		assert torch.allclose(inputs.pixel_values,							__a,							atol=1E-4    )

		SCREAMING_SNAKE_CASE_						 = model(**__a    )

		SCREAMING_SNAKE_CASE_						 = outputs.logits.argmax(-1    ).item()
		print('''Predicted class:''',							model.config.idalabel[predicted_class_idx]    )

		print('''First values of logits:''',							outputs.logits[0, :3]    )

		if model_name == "focalnet-tiny":
				SCREAMING_SNAKE_CASE_						 = torch.tensor([0.2_1_6_6, -0.4_3_6_8, 0.2_1_9_1]    )
		elif model_name == "focalnet-tiny-lrf":
				SCREAMING_SNAKE_CASE_						 = torch.tensor([1.1_6_6_9, 0.0_1_2_5, -0.1_6_9_5]    )
		elif model_name == "focalnet-small":
				SCREAMING_SNAKE_CASE_						 = torch.tensor([0.4_9_1_7, -0.0_4_3_0, 0.1_3_4_1]    )
		elif model_name == "focalnet-small-lrf":
				SCREAMING_SNAKE_CASE_						 = torch.tensor([-0.2_5_8_8, -0.5_3_4_2, -0.2_3_3_1]    )
		elif model_name == "focalnet-base":
				SCREAMING_SNAKE_CASE_						 = torch.tensor([-0.1_6_5_5, -0.4_0_9_0, -0.1_7_3_0]    )
		elif model_name == "focalnet-base-lrf":
				SCREAMING_SNAKE_CASE_						 = torch.tensor([0.5_3_0_6, -0.0_4_8_3, -0.3_9_2_8]    )
		assert torch.allclose(outputs.logits[0, :3],							__a,							atol=1E-4    )
		print('''Looks ok!'''    )

		if pytorch_dump_folder_path is not None:
				print(F'Saving model and processor of {model_name} to {pytorch_dump_folder_path}'    )
				model.save_pretrained(__a    )
				processor.save_pretrained(__a    )

		if push_to_hub:
				print(F'Pushing model and processor of {model_name} to the hub...'    )
				model.push_to_hub(F'{model_name}'    )
				processor.push_to_hub(F'{model_name}'    )


if __name__ == "__main__":
						lowerCAmelCase__							=				argparse.ArgumentParser()
						# Required parameters
						parser.add_argument(
						    '--model_name',
						    default='focalnet-tiny',
						    type=str,
						    help='Name of the FocalNet model 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 model and processor to the hub.',
						)

						lowerCAmelCase__							=				parser.parse_args()
						convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)