





"""simple docstring"""



import argparse
import json
from pathlib import Path

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

from transformers import YolosConfig, YolosForObjectDetection, YolosImageProcessor
from transformers.utils import logging


logging.set_verbosity_info()
a_					=     logging.get_logger(__name__)







def 						__lowercase	(  snake_case_    :    str		)  ->YolosConfig:



    '''simple docstring'''







    __A       :		Optional[int]							=	YolosConfig()

    # size of the architecture
    if "yolos_ti" in yolos_name:
        __A       :		List[Any]							=	192
        __A       :		Union[str, Any]							=	768
        __A       :		List[str]							=	12
        __A       :		Optional[int]							=	3
        __A       :		List[Any]							=	[800, 1333]
        __A       :		Optional[Any]							=	False
    elif yolos_name == "yolos_s_dWr":
        __A       :		Dict							=	330
        __A       :		Optional[Any]							=	14
        __A       :		Optional[Any]							=	6
        __A       :		int							=	1320
    elif "yolos_s" in yolos_name:
        __A       :		Any							=	384
        __A       :		Any							=	1536
        __A       :		str							=	12
        __A       :		int							=	6
    elif "yolos_b" in yolos_name:
        __A       :		int							=	[800, 1344]

    __A       :		List[str]							=	91
    __A       :		Union[str, Any]							=	'''huggingface/label-files'''
    __A       :		Union[str, Any]							=	'''coco-detection-id2label.json'''
    __A       :		str							=	json.load(open(hf_hub_download(snake_case_							,snake_case_							,repo_type='''dataset'''		)							,'''r'''		)		)
    __A       :		Tuple							=	{int(snake_case_		): v for k, v in idalabel.items()}
    __A       :		Dict							=	idalabel
    __A       :		Optional[Any]							=	{v: k for k, v in idalabel.items()}

    return config







def 						__lowercase	(  snake_case_    :    dict							,snake_case_    :    YolosConfig							,snake_case_    :    bool = False		)  ->str:



    '''simple docstring'''







    for i in range(config.num_hidden_layers		):
        # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
        __A       :		Optional[Any]							=	state_dict.pop(F"""blocks.{i}.attn.qkv.weight"""		)
        __A       :		Optional[Any]							=	state_dict.pop(F"""blocks.{i}.attn.qkv.bias"""		)
        # next, add query, keys and values (in that order) to the state dict
        __A       :		Optional[int]							=	in_proj_weight[: config.hidden_size, :]
        __A       :		int							=	in_proj_bias[: config.hidden_size]
        __A       :		List[str]							=	in_proj_weight[
            config.hidden_size : config.hidden_size * 2, :
        ]
        __A       :		Tuple							=	in_proj_bias[
            config.hidden_size : config.hidden_size * 2
        ]
        __A       :		str							=	in_proj_weight[-config.hidden_size :, :]
        __A       :		Union[str, Any]							=	in_proj_bias[-config.hidden_size :]







def 						__lowercase	(  snake_case_    :    str		)  ->str:



    '''simple docstring'''







    if "backbone" in name:
        __A       :		List[str]							=	name.replace('''backbone'''							,'''vit'''		)
    if "cls_token" in name:
        __A       :		List[Any]							=	name.replace('''cls_token'''							,'''embeddings.cls_token'''		)
    if "det_token" in name:
        __A       :		int							=	name.replace('''det_token'''							,'''embeddings.detection_tokens'''		)
    if "mid_pos_embed" in name:
        __A       :		Union[str, Any]							=	name.replace('''mid_pos_embed'''							,'''encoder.mid_position_embeddings'''		)
    if "pos_embed" in name:
        __A       :		List[Any]							=	name.replace('''pos_embed'''							,'''embeddings.position_embeddings'''		)
    if "patch_embed.proj" in name:
        __A       :		Dict							=	name.replace('''patch_embed.proj'''							,'''embeddings.patch_embeddings.projection'''		)
    if "blocks" in name:
        __A       :		Optional[Any]							=	name.replace('''blocks'''							,'''encoder.layer'''		)
    if "attn.proj" in name:
        __A       :		int							=	name.replace('''attn.proj'''							,'''attention.output.dense'''		)
    if "attn" in name:
        __A       :		Any							=	name.replace('''attn'''							,'''attention.self'''		)
    if "norm1" in name:
        __A       :		List[Any]							=	name.replace('''norm1'''							,'''layernorm_before'''		)
    if "norm2" in name:
        __A       :		Optional[Any]							=	name.replace('''norm2'''							,'''layernorm_after'''		)
    if "mlp.fc1" in name:
        __A       :		Optional[int]							=	name.replace('''mlp.fc1'''							,'''intermediate.dense'''		)
    if "mlp.fc2" in name:
        __A       :		Dict							=	name.replace('''mlp.fc2'''							,'''output.dense'''		)
    if "class_embed" in name:
        __A       :		Any							=	name.replace('''class_embed'''							,'''class_labels_classifier'''		)
    if "bbox_embed" in name:
        __A       :		str							=	name.replace('''bbox_embed'''							,'''bbox_predictor'''		)
    if "vit.norm" in name:
        __A       :		Tuple							=	name.replace('''vit.norm'''							,'''vit.layernorm'''		)

    return name







def 						__lowercase	(  snake_case_    :    dict							,snake_case_    :    YolosForObjectDetection		)  ->dict:



    '''simple docstring'''







    for key in orig_state_dict.copy().keys():
        __A       :		List[Any]							=	orig_state_dict.pop(snake_case_		)

        if "qkv" in key:
            __A       :		List[Any]							=	key.split('''.'''		)
            __A       :		List[Any]							=	int(key_split[2]		)
            __A       :		str							=	model.vit.encoder.layer[layer_num].attention.attention.all_head_size
            if "weight" in key:
                __A       :		int							=	val[:dim, :]
                __A       :		str							=	val[
                    dim : dim * 2, :
                ]
                __A       :		List[Any]							=	val[-dim:, :]
            else:
                __A       :		str							=	val[:dim]
                __A       :		Dict							=	val[dim : dim * 2]
                __A       :		Optional[int]							=	val[-dim:]
        else:
            __A       :		Tuple							=	val

    return orig_state_dict







def 						__lowercase	(  )  ->torch.Tensor:



    '''simple docstring'''







    __A       :		Optional[Any]							=	'''http://images.cocodataset.org/val2017/000000039769.jpg'''
    __A       :		Dict							=	Image.open(requests.get(snake_case_							,stream=snake_case_		).raw		)
    return im







@torch.no_grad()
def 						__lowercase	(  snake_case_    :    str							,snake_case_    :    str							,snake_case_    :    str							,snake_case_    :    bool = False		)  ->List[Any]:



    '''simple docstring'''







    __A       :		int							=	get_yolos_config(snake_case_		)

    # load original state_dict
    __A       :		Tuple							=	torch.load(snake_case_							,map_location='''cpu'''		)['''model''']

    # load 🤗 model
    __A       :		str							=	YolosForObjectDetection(snake_case_		)
    model.eval()
    __A       :		Tuple							=	convert_state_dict(snake_case_							,snake_case_		)
    model.load_state_dict(snake_case_		)

    # Check outputs on an image, prepared by YolosImageProcessor
    __A       :		Optional[int]							=	800 if yolos_name != '''yolos_ti''' else 512
    __A       :		int							=	YolosImageProcessor(format='''coco_detection'''							,size=snake_case_		)
    __A       :		Any							=	image_processor(images=prepare_img()							,return_tensors='''pt'''		)
    __A       :		Tuple							=	model(**snake_case_		)
    __A					,			__A       :		Any							=	outputs.logits, outputs.pred_boxes

    __A					,			__A       :		List[Any]							=	None, None
    if yolos_name == "yolos_ti":
        __A       :		List[Any]							=	torch.tensor(
            [[-39.5_022, -11.9_820, -17.6_888], [-29.9_574, -9.9_769, -17.7_691], [-42.3_281, -20.7_200, -30.6_294]]		)
        __A       :		str							=	torch.tensor(
            [[0.4_021, 0.0_836, 0.7_979], [0.0_184, 0.2_609, 0.0_364], [0.1_781, 0.2_004, 0.2_095]]		)
    elif yolos_name == "yolos_s_200_pre":
        __A       :		Optional[Any]							=	torch.tensor(
            [[-24.0_248, -10.3_024, -14.8_290], [-42.0_392, -16.8_200, -27.4_334], [-27.2_743, -11.8_154, -18.7_148]]		)
        __A       :		List[Any]							=	torch.tensor(
            [[0.2_559, 0.5_455, 0.4_706], [0.2_989, 0.7_279, 0.1_875], [0.7_732, 0.4_017, 0.4_462]]		)
    elif yolos_name == "yolos_s_300_pre":
        __A       :		Optional[Any]							=	torch.tensor(
            [[-36.2_220, -14.4_385, -23.5_457], [-35.6_970, -14.7_583, -21.3_935], [-31.5_939, -13.6_042, -16.8_049]]		)
        __A       :		Optional[int]							=	torch.tensor(
            [[0.7_614, 0.2_316, 0.4_728], [0.7_168, 0.4_495, 0.3_855], [0.4_996, 0.1_466, 0.9_996]]		)
    elif yolos_name == "yolos_s_dWr":
        __A       :		Union[str, Any]							=	torch.tensor(
            [[-42.8_668, -24.1_049, -41.1_690], [-34.7_456, -14.1_274, -24.9_194], [-33.7_898, -12.1_946, -25.6_495]]		)
        __A       :		Union[str, Any]							=	torch.tensor(
            [[0.5_587, 0.2_773, 0.0_605], [0.5_004, 0.3_014, 0.9_994], [0.4_999, 0.1_548, 0.9_994]]		)
    elif yolos_name == "yolos_base":
        __A       :		int							=	torch.tensor(
            [[-40.6_064, -24.3_084, -32.6_447], [-55.1_990, -30.7_719, -35.5_877], [-51.4_311, -33.3_507, -35.6_462]]		)
        __A       :		List[str]							=	torch.tensor(
            [[0.5_555, 0.2_794, 0.0_655], [0.9_049, 0.2_664, 0.1_894], [0.9_183, 0.1_984, 0.1_635]]		)
    else:
        raise ValueError(F"""Unknown yolos_name: {yolos_name}"""		)

    assert torch.allclose(logits[0, :3, :3]							,snake_case_							,atol=1e-4		)
    assert torch.allclose(pred_boxes[0, :3, :3]							,snake_case_							,atol=1e-4		)

    Path(snake_case_		).mkdir(exist_ok=snake_case_		)
    print(F"""Saving model {yolos_name} to {pytorch_dump_folder_path}"""		)
    model.save_pretrained(snake_case_		)
    print(F"""Saving image processor to {pytorch_dump_folder_path}"""		)
    image_processor.save_pretrained(snake_case_		)

    if push_to_hub:
        __A       :		Dict							=	{
            '''yolos_ti''': '''yolos-tiny''',
            '''yolos_s_200_pre''': '''yolos-small''',
            '''yolos_s_300_pre''': '''yolos-small-300''',
            '''yolos_s_dWr''': '''yolos-small-dwr''',
            '''yolos_base''': '''yolos-base''',
        }

        print('''Pushing to the hub...'''		)
        __A       :		List[Any]							=	model_mapping[yolos_name]
        image_processor.push_to_hub(snake_case_							,organization='''hustvl'''		)
        model.push_to_hub(snake_case_							,organization='''hustvl'''		)


if __name__ == "__main__":
       a_					=     argparse.ArgumentParser()
       # Required parameters
       parser.add_argument(
           """--yolos_name""",
           default="""yolos_s_200_pre""",
           type=str,
           help=(
               """Name of the YOLOS model you'd like to convert. Should be one of 'yolos_ti', 'yolos_s_200_pre',"""
               """ 'yolos_s_300_pre', 'yolos_s_dWr', 'yolos_base'."""
           ),
       )
       parser.add_argument(
           """--checkpoint_path""", default=None, type=str, help="""Path to the original state dict (.pth file)."""
       )
       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 or not to push the converted model to the 🤗 hub."""
       )

       a_					=     parser.parse_args()
       convert_yolos_checkpoint(args.yolos_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub)











"""simple docstring"""



import gc
import random
import unittest

import numpy as np
import torch

from diffusers import DDIMScheduler, KandinskyVaaPipeline, KandinskyVaaPriorPipeline, UNetaDConditionModel, VQModel
from diffusers.utils import floats_tensor, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()






class 						__snake_case   (						SCREAMING_SNAKE_CASE__				,				unittest.TestCase	):





 """simple docstring"""


 _lowerCamelCase								=	KandinskyVaaPipeline
 _lowerCamelCase								=	[
     """image_embeds""",
     """negative_image_embeds""",
 ]
 _lowerCamelCase								=	["""image_embeds""", """negative_image_embeds"""]
 _lowerCamelCase								=	[
     """generator""",
     """height""",
     """width""",
     """latents""",
     """guidance_scale""",
     """num_inference_steps""",
     """return_dict""",
     """guidance_scale""",
     """num_images_per_prompt""",
     """output_type""",
     """return_dict""",
 ]
 _lowerCamelCase								=	False

 @property
 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     return 32

 @property
 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     return 32

 @property
 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     return self.time_input_dim

 @property
 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     return self.time_input_dim * 4

 @property
 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     return 100

 @property
 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     torch.manual_seed(0    )

     __A       :		Optional[Any]							=	{
         '''in_channels''': 4,
         # Out channels is double in channels because predicts mean and variance
         '''out_channels''': 8,
         '''addition_embed_type''': '''image''',
         '''down_block_types''': ('''ResnetDownsampleBlock2D''', '''SimpleCrossAttnDownBlock2D'''),
         '''up_block_types''': ('''SimpleCrossAttnUpBlock2D''', '''ResnetUpsampleBlock2D'''),
         '''mid_block_type''': '''UNetMidBlock2DSimpleCrossAttn''',
         '''block_out_channels''': (self.block_out_channels_a, self.block_out_channels_a * 2),
         '''layers_per_block''': 1,
         '''encoder_hid_dim''': self.text_embedder_hidden_size,
         '''encoder_hid_dim_type''': '''image_proj''',
         '''cross_attention_dim''': self.cross_attention_dim,
         '''attention_head_dim''': 4,
         '''resnet_time_scale_shift''': '''scale_shift''',
         '''class_embed_type''': None,
     }

     __A       :		Optional[Any]							=	UNetaDConditionModel(**__lowerCamelCase    )
     return model

 @property
 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     return {
         "block_out_channels": [32, 64],
         "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"],
         "in_channels": 3,
         "latent_channels": 4,
         "layers_per_block": 1,
         "norm_num_groups": 8,
         "norm_type": "spatial",
         "num_vq_embeddings": 12,
         "out_channels": 3,
         "up_block_types": [
             "AttnUpDecoderBlock2D",
             "UpDecoderBlock2D",
         ],
         "vq_embed_dim": 4,
     }

 @property
 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     torch.manual_seed(0    )
     __A       :		Tuple							=	VQModel(**self.dummy_movq_kwargs    )
     return model

 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     __A       :		List[Any]							=	self.dummy_unet
     __A       :		Optional[int]							=	self.dummy_movq

     __A       :		List[Any]							=	DDIMScheduler(
         num_train_timesteps=1000   ,		beta_schedule='''linear'''   ,		beta_start=0.0_0_0_8_5   ,		beta_end=0.0_1_2   ,		clip_sample=__lowerCamelCase   ,		set_alpha_to_one=__lowerCamelCase   ,		steps_offset=1   ,		prediction_type='''epsilon'''   ,		thresholding=__lowerCamelCase   ,		)

     __A       :		Optional[int]							=	{
         '''unet''': unet,
         '''scheduler''': scheduler,
         '''movq''': movq,
     }
     return components

 def    UpperCamelCase__(       self   ,		__lowerCamelCase   ,		__lowerCamelCase=0    ):



     '''simple docstring'''




     __A       :		Optional[int]							=	floats_tensor((1, self.text_embedder_hidden_size)   ,		rng=random.Random(__lowerCamelCase    )    ).to(__lowerCamelCase    )
     __A       :		List[Any]							=	floats_tensor((1, self.text_embedder_hidden_size)   ,		rng=random.Random(seed + 1    )    ).to(
         __lowerCamelCase    )
     if str(__lowerCamelCase    ).startswith('''mps'''    ):
         __A       :		Optional[Any]							=	torch.manual_seed(__lowerCamelCase    )
     else:
         __A       :		Dict							=	torch.Generator(device=__lowerCamelCase    ).manual_seed(__lowerCamelCase    )
     __A       :		Dict							=	{
         '''image_embeds''': image_embeds,
         '''negative_image_embeds''': negative_image_embeds,
         '''generator''': generator,
         '''height''': 64,
         '''width''': 64,
         '''guidance_scale''': 4.0,
         '''num_inference_steps''': 2,
         '''output_type''': '''np''',
     }
     return inputs







 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     __A       :		str							=	'''cpu'''

     __A       :		str							=	self.get_dummy_components()

     __A       :		Dict							=	self.pipeline_class(**__lowerCamelCase    )
     __A       :		Tuple							=	pipe.to(__lowerCamelCase    )

     pipe.set_progress_bar_config(disable=__lowerCamelCase    )

     __A       :		List[str]							=	pipe(**self.get_dummy_inputs(__lowerCamelCase    )    )
     __A       :		Tuple							=	output.images

     __A       :		Tuple							=	pipe(
         **self.get_dummy_inputs(__lowerCamelCase    )   ,		return_dict=__lowerCamelCase   ,		)[0]

     __A       :		Dict							=	image[0, -3:, -3:, -1]
     __A       :		Any							=	image_from_tuple[0, -3:, -3:, -1]

     assert image.shape == (1, 64, 64, 3)

     __A       :		Optional[int]							=	np.array(
         [0.6_2_3_7_9_7_6, 1.0, 0.3_6_4_4_1_3_3_2, 1.0, 0.7_0_6_3_9_6_3_4, 0.2_9_8_7_7_1_8_6, 0.8_5_6_5_2_1_2_5, 0.5_2_1_6_8_4_3, 0.5_4_4_5_4_0_4_6]    )

     assert (
         np.abs(image_slice.flatten() - expected_slice    ).max() < 1e-2
     ), F""" expected_slice {expected_slice}, but got {image_slice.flatten()}"""

     assert (
         np.abs(image_from_tuple_slice.flatten() - expected_slice    ).max() < 1e-2
     ), F""" expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}"""






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





 """simple docstring"""


 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




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







 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     __A       :		Any							=	load_numpy(
         '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
         '''/kandinskyv22/kandinskyv22_text2img_cat_fp16.npy'''    )

     __A       :		Optional[Any]							=	KandinskyVaaPriorPipeline.from_pretrained(
         '''kandinsky-community/kandinsky-2-2-prior'''   ,		torch_dtype=torch.floataa    )
     pipe_prior.to(__lowerCamelCase    )

     __A       :		int							=	KandinskyVaaPipeline.from_pretrained(
         '''kandinsky-community/kandinsky-2-2-decoder'''   ,		torch_dtype=torch.floataa    )
     __A       :		Union[str, Any]							=	pipeline.to(__lowerCamelCase    )
     pipeline.set_progress_bar_config(disable=__lowerCamelCase    )

     __A       :		List[Any]							=	'''red cat, 4k photo'''

     __A       :		Union[str, Any]							=	torch.Generator(device='''cuda'''    ).manual_seed(0    )
     __A					,			__A       :		List[str]							=	pipe_prior(
         __lowerCamelCase   ,		generator=__lowerCamelCase   ,		num_inference_steps=5   ,		negative_prompt=''''''   ,		).to_tuple()

     __A       :		Any							=	torch.Generator(device='''cuda'''    ).manual_seed(0    )
     __A       :		Optional[int]							=	pipeline(
         image_embeds=__lowerCamelCase   ,		negative_image_embeds=__lowerCamelCase   ,		generator=__lowerCamelCase   ,		num_inference_steps=100   ,		output_type='''np'''   ,		)

     __A       :		Union[str, Any]							=	output.images[0]

     assert image.shape == (512, 512, 3)

     assert_mean_pixel_difference(__lowerCamelCase   ,		__lowerCamelCase    )




