
"""simple docstring"""




import gc
import random
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, CycleDiffusionPipeline, DDIMScheduler, UNetaDConditionModel
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()





class  snake_case     (							__lowercase       ,			__lowercase       ,			unittest.TestCase   ):
							UpperCAmelCase__						     =      CycleDiffusionPipeline
							UpperCAmelCase__						     =      TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {
							    '''negative_prompt''',
							    '''height''',
							    '''width''',
							    '''negative_prompt_embeds''',
							}
							UpperCAmelCase__						     =      PipelineTesterMixin.required_optional_params - {'''latents'''}
							UpperCAmelCase__						     =      TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'''source_prompt'''}   )
							UpperCAmelCase__						     =      IMAGE_TO_IMAGE_IMAGE_PARAMS
							UpperCAmelCase__						     =      IMAGE_TO_IMAGE_IMAGE_PARAMS

							def _lowercase					(self    ):

									"""simple docstring"""







									torch.manual_seed(0    )
									SCREAMING_SNAKE_CASE_						 = UNetaDConditionModel(
									    block_out_channels=(32, 64)       ,       layers_per_block=2       ,       sample_size=32       ,       in_channels=4       ,       out_channels=4       ,       down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')       ,       up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')       ,       cross_attention_dim=32       ,       )
									SCREAMING_SNAKE_CASE_						 = DDIMScheduler(
									    beta_start=0.0_00_85       ,       beta_end=0.0_12       ,       beta_schedule='''scaled_linear'''       ,       num_train_timesteps=10_00       ,       clip_sample=SCREAMING_SNAKE_CASE_       ,       set_alpha_to_one=SCREAMING_SNAKE_CASE_       ,       )
									torch.manual_seed(0    )
									SCREAMING_SNAKE_CASE_						 = AutoencoderKL(
									    block_out_channels=[32, 64]       ,       in_channels=3       ,       out_channels=3       ,       down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']       ,       up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']       ,       latent_channels=4       ,       )
									torch.manual_seed(0    )
									SCREAMING_SNAKE_CASE_						 = CLIPTextConfig(
									    bos_token_id=0       ,       eos_token_id=2       ,       hidden_size=32       ,       intermediate_size=37       ,       layer_norm_eps=1e-0_5       ,       num_attention_heads=4       ,       num_hidden_layers=5       ,       pad_token_id=1       ,       vocab_size=10_00       ,       )
									SCREAMING_SNAKE_CASE_						 = CLIPTextModel(SCREAMING_SNAKE_CASE_    )
									SCREAMING_SNAKE_CASE_						 = CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''    )

									SCREAMING_SNAKE_CASE_						 = {
									    '''unet''': unet,
									    '''scheduler''': scheduler,
									    '''vae''': vae,
									    '''text_encoder''': text_encoder,
									    '''tokenizer''': tokenizer,
									    '''safety_checker''': None,
									    '''feature_extractor''': None,
									}
									return components

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

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = floats_tensor((1, 3, 32, 32)       ,       rng=random.Random(SCREAMING_SNAKE_CASE_    )    ).to(SCREAMING_SNAKE_CASE_    )
									SCREAMING_SNAKE_CASE_						 = image / 2 + 0.5
									if str(SCREAMING_SNAKE_CASE_    ).startswith('''mps'''    ):
											SCREAMING_SNAKE_CASE_						 = torch.manual_seed(SCREAMING_SNAKE_CASE_    )
									else:
											SCREAMING_SNAKE_CASE_						 = torch.Generator(device=SCREAMING_SNAKE_CASE_    ).manual_seed(SCREAMING_SNAKE_CASE_    )
									SCREAMING_SNAKE_CASE_						 = {
									    '''prompt''': '''An astronaut riding an elephant''',
									    '''source_prompt''': '''An astronaut riding a horse''',
									    '''image''': image,
									    '''generator''': generator,
									    '''num_inference_steps''': 2,
									    '''eta''': 0.1,
									    '''strength''': 0.8,
									    '''guidance_scale''': 3,
									    '''source_guidance_scale''': 1,
									    '''output_type''': '''numpy''',
									}
									return inputs

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = '''cpu'''  # ensure determinism for the device-dependent torch.Generator

									SCREAMING_SNAKE_CASE_						 = self.get_dummy_components()
									SCREAMING_SNAKE_CASE_						 = CycleDiffusionPipeline(**SCREAMING_SNAKE_CASE_    )
									SCREAMING_SNAKE_CASE_						 = pipe.to(SCREAMING_SNAKE_CASE_    )
									pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_    )

									SCREAMING_SNAKE_CASE_						 = self.get_dummy_inputs(SCREAMING_SNAKE_CASE_    )
									SCREAMING_SNAKE_CASE_						 = pipe(**SCREAMING_SNAKE_CASE_    )
									SCREAMING_SNAKE_CASE_						 = output.images

									SCREAMING_SNAKE_CASE_						 = images[0, -3:, -3:, -1]

									assert images.shape == (1, 32, 32, 3)
									SCREAMING_SNAKE_CASE_						 = np.array([0.44_59, 0.49_43, 0.45_44, 0.66_43, 0.54_74, 0.43_27, 0.57_01, 0.59_59, 0.51_79]    )

									assert np.abs(image_slice.flatten() - expected_slice    ).max() < 1e-2

							@unittest.skipIf(torch_device != '''cuda'''       ,       '''This test requires a GPU'''    )
							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = self.get_dummy_components()
									for name, module in components.items():
											if hasattr(SCREAMING_SNAKE_CASE_       ,       '''half'''    ):
													SCREAMING_SNAKE_CASE_						 = module.half()
									SCREAMING_SNAKE_CASE_						 = CycleDiffusionPipeline(**SCREAMING_SNAKE_CASE_    )
									SCREAMING_SNAKE_CASE_						 = pipe.to(SCREAMING_SNAKE_CASE_    )
									pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_    )

									SCREAMING_SNAKE_CASE_						 = self.get_dummy_inputs(SCREAMING_SNAKE_CASE_    )
									SCREAMING_SNAKE_CASE_						 = pipe(**SCREAMING_SNAKE_CASE_    )
									SCREAMING_SNAKE_CASE_						 = output.images

									SCREAMING_SNAKE_CASE_						 = images[0, -3:, -3:, -1]

									assert images.shape == (1, 32, 32, 3)
									SCREAMING_SNAKE_CASE_						 = np.array([0.35_06, 0.45_43, 0.4_46, 0.45_75, 0.51_95, 0.41_55, 0.52_73, 0.5_18, 0.41_16]    )

									assert np.abs(image_slice.flatten() - expected_slice    ).max() < 1e-2

							@skip_mps
							def _lowercase					(self    ):

									"""simple docstring"""







									return super().test_save_load_local()

							@unittest.skip('''non-deterministic pipeline'''    )
							def _lowercase					(self    ):

									"""simple docstring"""







									return super().test_inference_batch_single_identical()

							@skip_mps
							def _lowercase					(self    ):

									"""simple docstring"""







									return super().test_dict_tuple_outputs_equivalent()

							@skip_mps
							def _lowercase					(self    ):

									"""simple docstring"""







									return super().test_save_load_optional_components()







							@skip_mps
							def _lowercase					(self    ):

									"""simple docstring"""







									return super().test_attention_slicing_forward_pass()







@slow
@require_torch_gpu
class  snake_case     (							unittest.TestCase   ):

							def _lowercase					(self    ):

									"""simple docstring"""







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

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = load_image(
									    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
									    '''/cycle-diffusion/black_colored_car.png'''    )
									SCREAMING_SNAKE_CASE_						 = load_numpy(
									    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/cycle-diffusion/blue_colored_car_fp16.npy'''    )
									SCREAMING_SNAKE_CASE_						 = init_image.resize((5_12, 5_12)    )

									SCREAMING_SNAKE_CASE_						 = '''CompVis/stable-diffusion-v1-4'''
									SCREAMING_SNAKE_CASE_						 = DDIMScheduler.from_pretrained(SCREAMING_SNAKE_CASE_       ,       subfolder='''scheduler'''    )
									SCREAMING_SNAKE_CASE_						 = CycleDiffusionPipeline.from_pretrained(
									    SCREAMING_SNAKE_CASE_       ,       scheduler=SCREAMING_SNAKE_CASE_       ,       safety_checker=SCREAMING_SNAKE_CASE_       ,       torch_dtype=torch.floataa       ,       revision='''fp16'''    )

									pipe.to(SCREAMING_SNAKE_CASE_    )
									pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_    )
									pipe.enable_attention_slicing()

									SCREAMING_SNAKE_CASE_						 = '''A black colored car'''
									SCREAMING_SNAKE_CASE_						 = '''A blue colored car'''

									SCREAMING_SNAKE_CASE_						 = torch.manual_seed(0    )
									SCREAMING_SNAKE_CASE_						 = pipe(
									    prompt=SCREAMING_SNAKE_CASE_       ,       source_prompt=SCREAMING_SNAKE_CASE_       ,       image=SCREAMING_SNAKE_CASE_       ,       num_inference_steps=1_00       ,       eta=0.1       ,       strength=0.85       ,       guidance_scale=3       ,       source_guidance_scale=1       ,       generator=SCREAMING_SNAKE_CASE_       ,       output_type='''np'''       ,       )
									SCREAMING_SNAKE_CASE_						 = output.images

									# the values aren't exactly equal, but the images look the same visually
									assert np.abs(image - expected_image    ).max() < 5e-1







							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = load_image(
									    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
									    '''/cycle-diffusion/black_colored_car.png'''    )
									SCREAMING_SNAKE_CASE_						 = load_numpy(
									    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/cycle-diffusion/blue_colored_car.npy'''    )
									SCREAMING_SNAKE_CASE_						 = init_image.resize((5_12, 5_12)    )

									SCREAMING_SNAKE_CASE_						 = '''CompVis/stable-diffusion-v1-4'''
									SCREAMING_SNAKE_CASE_						 = DDIMScheduler.from_pretrained(SCREAMING_SNAKE_CASE_       ,       subfolder='''scheduler'''    )
									SCREAMING_SNAKE_CASE_						 = CycleDiffusionPipeline.from_pretrained(SCREAMING_SNAKE_CASE_       ,       scheduler=SCREAMING_SNAKE_CASE_       ,       safety_checker=SCREAMING_SNAKE_CASE_    )

									pipe.to(SCREAMING_SNAKE_CASE_    )
									pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_    )
									pipe.enable_attention_slicing()

									SCREAMING_SNAKE_CASE_						 = '''A black colored car'''
									SCREAMING_SNAKE_CASE_						 = '''A blue colored car'''

									SCREAMING_SNAKE_CASE_						 = torch.manual_seed(0    )
									SCREAMING_SNAKE_CASE_						 = pipe(
									    prompt=SCREAMING_SNAKE_CASE_       ,       source_prompt=SCREAMING_SNAKE_CASE_       ,       image=SCREAMING_SNAKE_CASE_       ,       num_inference_steps=1_00       ,       eta=0.1       ,       strength=0.85       ,       guidance_scale=3       ,       source_guidance_scale=1       ,       generator=SCREAMING_SNAKE_CASE_       ,       output_type='''np'''       ,       )
									SCREAMING_SNAKE_CASE_						 = output.images

									assert np.abs(image - expected_image    ).max() < 2e-2

"""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)