






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      __lowercase					( snake_case ):







				"""simple docstring"""






				__magic_name__		:Union[str, Any]        =      [2, 2, 6, 2] if '''tiny''' in model_name else [2, 2, 1_8, 2]
				__magic_name__		:Union[str, Any]        =      True if '''large''' in model_name or '''huge''' in model_name else False
				__magic_name__		:Any        =      True if '''large''' in model_name or '''huge''' in model_name else False
				__magic_name__		:List[str]        =      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:
												__magic_name__		:Union[str, Any]        =      [3, 3, 3, 3]
												__magic_name__		:str        =      [5, 5, 5, 5]
								elif "fl4" in model_name:
												__magic_name__		:int        =      [4, 4, 4, 4]
												__magic_name__		:Optional[int]        =      [3, 3, 3, 3]

				if "tiny" in model_name or "small" in model_name or "base" in model_name:
								__magic_name__		:List[Any]        =      [3, 3, 3, 3]
								if "lrf" in model_name:
												__magic_name__		:Optional[int]        =      [3, 3, 3, 3]
								else:
												__magic_name__		:Union[str, Any]        =      [2, 2, 2, 2]

				if "tiny" in model_name:
								__magic_name__		:Tuple        =      9_6
				elif "small" in model_name:
								__magic_name__		:Any        =      9_6
				elif "base" in model_name:
								__magic_name__		:int        =      1_2_8
				elif "large" in model_name:
								__magic_name__		:List[Any]        =      1_9_2
				elif "xlarge" in model_name:
								__magic_name__		:int        =      2_5_6
				elif "huge" in model_name:
								__magic_name__		:Any        =      3_5_2

				# set label information
				__magic_name__		:Optional[int]        =      '''huggingface/label-files'''
				if "large" in model_name or "huge" in model_name:
								__magic_name__		:List[str]        =      '''imagenet-22k-id2label.json'''
				else:
								__magic_name__		:Tuple        =      '''imagenet-1k-id2label.json'''

				__magic_name__		:Tuple        =      json.load(open(hf_hub_download(snake_case,  snake_case,  repo_type='''dataset''' ),  '''r''' ) )
				__magic_name__		:Tuple        =      {int(snake_case ): v for k, v in idalabel.items()}
				__magic_name__		:Dict        =      {v: k for k, v in idalabel.items()}

				__magic_name__		:List[str]        =      FocalNetConfig(
				    embed_dim=snake_case,  depths=snake_case,  focal_levels=snake_case,  focal_windows=snake_case,  use_conv_embed=snake_case,  idalabel=snake_case,  labelaid=snake_case,  use_post_layernorm=snake_case,  use_layerscale=snake_case,  )

				return config

def      __lowercase					( snake_case ):







				"""simple docstring"""






				if "patch_embed.proj" in name:
								__magic_name__		:Union[str, Any]        =      name.replace('''patch_embed.proj''',  '''embeddings.patch_embeddings.projection''' )
				if "patch_embed.norm" in name:
								__magic_name__		:Optional[Any]        =      name.replace('''patch_embed.norm''',  '''embeddings.norm''' )
				if "layers" in name:
								__magic_name__		:str        =      '''encoder.''' + name
				if "encoder.layers" in name:
								__magic_name__		:Union[str, Any]        =      name.replace('''encoder.layers''',  '''encoder.stages''' )
				if "downsample.proj" in name:
								__magic_name__		:Tuple        =      name.replace('''downsample.proj''',  '''downsample.projection''' )
				if "blocks" in name:
								__magic_name__		:str        =      name.replace('''blocks''',  '''layers''' )
				if "modulation.f.weight" in name or "modulation.f.bias" in name:
								__magic_name__		:Optional[Any]        =      name.replace('''modulation.f''',  '''modulation.projection_in''' )
				if "modulation.h.weight" in name or "modulation.h.bias" in name:
								__magic_name__		:List[str]        =      name.replace('''modulation.h''',  '''modulation.projection_context''' )
				if "modulation.proj.weight" in name or "modulation.proj.bias" in name:
								__magic_name__		:Any        =      name.replace('''modulation.proj''',  '''modulation.projection_out''' )

				if name == "norm.weight":
								__magic_name__		:Optional[Any]        =      '''layernorm.weight'''
				if name == "norm.bias":
								__magic_name__		:List[Any]        =      '''layernorm.bias'''

				if "head" in name:
								__magic_name__		:Dict        =      name.replace('''head''',  '''classifier''' )
				else:
								__magic_name__		:List[str]        =      '''focalnet.''' + name

				return name

def      __lowercase					( snake_case,  snake_case,  snake_case=False ):







				"""simple docstring"""






				__magic_name__		:Tuple        =      {
				    '''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

				__magic_name__		:str        =      model_name_to_url[model_name]
				print('''Checkpoint URL: ''',  snake_case )
				__magic_name__		:Dict        =      torch.hub.load_state_dict_from_url(snake_case,  map_location='''cpu''' )['''model''']

				# rename keys
				for key in state_dict.copy().keys():
								__magic_name__		:List[str]        =      state_dict.pop(snake_case )
								__magic_name__		:Any        =      val

				__magic_name__		:Dict        =      get_focalnet_config(snake_case )
				__magic_name__		:Tuple        =      FocalNetForImageClassification(snake_case )
				model.eval()

				# load state dict
				model.load_state_dict(snake_case )

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

				__magic_name__		:Union[str, Any]        =      BitImageProcessor(
				    do_resize=snake_case,  size={'''shortest_edge''': 2_5_6},  resample=PILImageResampling.BILINEAR,  do_center_crop=snake_case,  crop_size=2_2_4,  do_normalize=snake_case,  image_mean=snake_case,  image_std=snake_case,  )
				__magic_name__		:Optional[int]        =      Image.open(requests.get(snake_case,  stream=snake_case ).raw )
				__magic_name__		:Union[str, Any]        =      processor(images=snake_case,  return_tensors='''pt''' )

				__magic_name__		:str        =      transforms.Compose(
				    [
				        transforms.Resize(2_5_6 ),
				        transforms.CenterCrop(2_2_4 ),
				        transforms.ToTensor(),
				        transforms.Normalize(mean=[0.485, 0.456, 0.406],  std=[0.229, 0.224, 0.225] ),
				    ] )

				__magic_name__		:Any        =      image_transforms(snake_case ).unsqueeze(0 )

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

				__magic_name__		:List[Any]        =      model(**snake_case )

				__magic_name__		:Any        =      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":
								__magic_name__		:List[str]        =      torch.tensor([0.2166, -0.4368, 0.2191] )
				elif model_name == "focalnet-tiny-lrf":
								__magic_name__		:List[Any]        =      torch.tensor([1.1669, 0.0125, -0.1695] )
				elif model_name == "focalnet-small":
								__magic_name__		:Optional[Any]        =      torch.tensor([0.4917, -0.0430, 0.1341] )
				elif model_name == "focalnet-small-lrf":
								__magic_name__		:int        =      torch.tensor([-0.2588, -0.5342, -0.2331] )
				elif model_name == "focalnet-base":
								__magic_name__		:List[str]        =      torch.tensor([-0.1655, -0.4090, -0.1730] )
				elif model_name == "focalnet-base-lrf":
								__magic_name__		:int        =      torch.tensor([0.5306, -0.0483, -0.3928] )
				assert torch.allclose(outputs.logits[0, :3],  snake_case,  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(snake_case )
								processor.save_pretrained(snake_case )

				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__":
					SCREAMING_SNAKE_CASE__      :			int							=		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.""",
					)

					SCREAMING_SNAKE_CASE__      :			Tuple							=		parser.parse_args()
					convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)














import argparse
import math
import os

import torch
from neural_compressor.utils.pytorch import load
from PIL import Image
from transformers import CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, StableDiffusionPipeline, UNetaDConditionModel

def      __lowercase					( ):







				"""simple docstring"""






				__magic_name__		:Optional[int]        =      argparse.ArgumentParser()
				parser.add_argument(
				    '''-m''',  '''--pretrained_model_name_or_path''',  type=snake_case,  default=snake_case,  required=snake_case,  help='''Path to pretrained model or model identifier from huggingface.co/models.''',  )
				parser.add_argument(
				    '''-c''',  '''--caption''',  type=snake_case,  default='''robotic cat with wings''',  help='''Text used to generate images.''',  )
				parser.add_argument(
				    '''-n''',  '''--images_num''',  type=snake_case,  default=4,  help='''How much images to generate.''',  )
				parser.add_argument(
				    '''-s''',  '''--seed''',  type=snake_case,  default=4_2,  help='''Seed for random process.''',  )
				parser.add_argument(
				    '''-ci''',  '''--cuda_id''',  type=snake_case,  default=0,  help='''cuda_id.''',  )
				__magic_name__		:Optional[Any]        =      parser.parse_args()
				return args

def      __lowercase					( snake_case,  snake_case,  snake_case ):







				"""simple docstring"""






				if not len(snake_case ) == rows * cols:
								raise ValueError('''The specified number of rows and columns are not correct.''' )

				__magic_name__     ,				__magic_name__		:Tuple        =      imgs[0].size
				__magic_name__		:List[Any]        =      Image.new('''RGB''',  size=(cols * w, rows * h) )
				__magic_name__     ,				__magic_name__		:List[Any]        =      grid.size

				for i, img in enumerate(snake_case ):
								grid.paste(snake_case,  box=(i % cols * w, i // cols * h) )
				return grid

def      __lowercase					( snake_case,  snake_case="robotic cat with wings",  snake_case=7.5,  snake_case=5_0,  snake_case=1,  snake_case=4_2,  ):







				"""simple docstring"""






				__magic_name__		:List[Any]        =      torch.Generator(pipeline.device ).manual_seed(snake_case )
				__magic_name__		:str        =      pipeline(
				    snake_case,  guidance_scale=snake_case,  num_inference_steps=snake_case,  generator=snake_case,  num_images_per_prompt=snake_case,  ).images
				__magic_name__		:Tuple        =      int(math.sqrt(snake_case ) )
				__magic_name__		:Union[str, Any]        =      image_grid(snake_case,  rows=_rows,  cols=num_images_per_prompt // _rows )
				return grid, images


SCREAMING_SNAKE_CASE__      :			Any							=		parse_args()
# Load models and create wrapper for stable diffusion
SCREAMING_SNAKE_CASE__      :			int							=		CLIPTokenizer.from_pretrained(args.pretrained_model_name_or_path, subfolder="""tokenizer""")
SCREAMING_SNAKE_CASE__      :			str							=		CLIPTextModel.from_pretrained(args.pretrained_model_name_or_path, subfolder="""text_encoder""")
SCREAMING_SNAKE_CASE__      :			Optional[Any]							=		AutoencoderKL.from_pretrained(args.pretrained_model_name_or_path, subfolder="""vae""")
SCREAMING_SNAKE_CASE__      :			int							=		UNetaDConditionModel.from_pretrained(args.pretrained_model_name_or_path, subfolder="""unet""")

SCREAMING_SNAKE_CASE__      :			Union[str, Any]							=		StableDiffusionPipeline.from_pretrained(
    args.pretrained_model_name_or_path, text_encoder=text_encoder, vae=vae, unet=unet, tokenizer=tokenizer
)
SCREAMING_SNAKE_CASE__      :			str							=		lambda images, clip_input: (images, False)
if os.path.exists(os.path.join(args.pretrained_model_name_or_path, """best_model.pt""")):
					SCREAMING_SNAKE_CASE__      :			str							=		load(args.pretrained_model_name_or_path, model=unet)
					unet.eval()
					setattr(pipeline, """unet""", unet)
else:
					SCREAMING_SNAKE_CASE__      :			Dict							=		unet.to(torch.device("""cuda""", args.cuda_id))
SCREAMING_SNAKE_CASE__      :			Any							=		pipeline.to(unet.device)
SCREAMING_SNAKE_CASE__							,					SCREAMING_SNAKE_CASE__      :			Dict							=		generate_images(pipeline, prompt=args.caption, num_images_per_prompt=args.images_num, seed=args.seed)
grid.save(os.path.join(args.pretrained_model_name_or_path, """{}.png""".format("""_""".join(args.caption.split()))))
SCREAMING_SNAKE_CASE__      :			int							=		os.path.join(args.pretrained_model_name_or_path, """_""".join(args.caption.split()))
os.makedirs(dirname, exist_ok=True)
for idx, image in enumerate(images):
					image.save(os.path.join(dirname, """{}.png""".format(idx + 1)))






