Upload 4 files

catvton_quantization_helper.py

@@ -0,0 +1,143 @@
+from typing import Any
+from pathlib import Path
+import pickle
+
+from tqdm.notebook import tqdm
+from transformers import set_seed
+import numpy as np
+import openvino as ov
+from PIL import Image
+import torch
+import nncf
+
+from ov_catvton_helper import (
+    MODEL_DIR,
+    VAE_ENCODER_PATH,
+    VAE_DECODER_PATH,
+    UNET_PATH,
+    DENSEPOSE_PROCESSOR_PATH,
+    SCHP_PROCESSOR_ATR,
+    SCHP_PROCESSOR_LIP,
+)
+
+set_seed(42)
+NUM_INFERENCE_STEPS = 50
+GUIDANCE_SCALE = 2.5
+GENERATOR = torch.Generator(device="cpu").manual_seed(42)
+
+VAE_ENCODER_INT4_PATH = MODEL_DIR / "vae_encoder_int4.xml"
+VAE_DECODER_INT4_PATH = MODEL_DIR / "vae_decoder_int4.xml"
+UNET_INT8_PATH = MODEL_DIR / "unet_int8.xml"
+DENSEPOSE_PROCESSOR_INT4_PATH = MODEL_DIR / "densepose_processor_int4.xml"
+SCHP_PROCESSOR_ATR_INT4 = MODEL_DIR / "schp_processor_atr_int4.xml"
+SCHP_PROCESSOR_LIP_INT4 = MODEL_DIR / "schp_processor_lip_int4.xml"
+
+
+class CompiledModelDecorator(ov.CompiledModel):
+    def __init__(
+        self,
+        compiled_model: ov.CompiledModel,
+        data_cache: list[Any] = None,
+        keep_prob: float = 1.0,
+    ):
+        super().__init__(compiled_model)
+        self.data_cache = data_cache if data_cache is not None else []
+        self.keep_prob = keep_prob
+
+    def __call__(self, *args, **kwargs):
+        if np.random.rand() <= self.keep_prob:
+            self.data_cache.append(*args)
+        return super().__call__(*args, **kwargs)
+
+
+def collect_calibration_data(pipeline, automasker, mask_processor, dataset, subset_size):
+    calibration_dataset_filepath = Path("calibration_data") / f"{subset_size}.pkl"
+    calibration_dataset_filepath.parent.mkdir(exist_ok=True, parents=True)
+
+    if not calibration_dataset_filepath.exists():
+        original_unet = pipeline.unet.unet
+        pipeline.unet.unet = CompiledModelDecorator(original_unet)
+
+        calibration_dataset = []
+        pbar = tqdm(total=subset_size, desc="Collecting calibration dataset")
+        for data in dataset:
+            person_image_path, cloth_image_path = data
+            person_image = Image.open(person_image_path)
+            cloth_image = Image.open(cloth_image_path)
+            cloth_type = "upper" if "upper" in person_image_path.as_posix() else "overall"
+            mask = automasker(person_image, cloth_type)["mask"]
+            mask = mask_processor.blur(mask, blur_factor=9)
+
+            pipeline(
+                image=person_image,
+                condition_image=cloth_image,
+                mask=mask,
+                num_inference_steps=NUM_INFERENCE_STEPS,
+                guidance_scale=GUIDANCE_SCALE,
+                generator=GENERATOR,
+            )
+            collected_subset_size = len(pipeline.unet.unet.data_cache)
+            pbar.update(NUM_INFERENCE_STEPS)
+            if collected_subset_size >= subset_size:
+                break
+
+        calibration_dataset = pipeline.unet.unet.data_cache
+        pipeline.unet.unet = original_unet
+
+        with open(calibration_dataset_filepath, "wb") as f:
+            pickle.dump(calibration_dataset, f)
+    else:
+        with open(calibration_dataset_filepath, "rb") as f:
+            calibration_dataset = pickle.load(f)
+
+    return calibration_dataset
+
+
+def compress_model(core, model_path, save_path, group_size=128, ratio=0.8):
+    if not save_path.exists():
+        print(f"{model_path.stem} compression started")
+        print(f"Compression parameters:\n\tmode = {nncf.CompressWeightsMode.INT4_SYM}\n\tratio = {ratio}\n\tgroup_size = {group_size}")
+        model = core.read_model(model_path)
+        compressed_model = nncf.compress_weights(
+            model,
+            mode=nncf.CompressWeightsMode.INT4_SYM,
+            ratio=ratio,
+            group_size=group_size,
+        )
+        ov.save_model(compressed_model, save_path)
+        print(f"{model_path.stem} compression finished")
+    print(f"Compressed {model_path.stem} can be found in {save_path}")
+
+
+def compress_models(core, group_size=128, ratio=0.8):
+    compress_model(core, VAE_ENCODER_PATH, VAE_ENCODER_INT4_PATH, group_size, ratio)
+    compress_model(core, VAE_DECODER_PATH, VAE_DECODER_INT4_PATH, group_size, ratio)
+    compress_model(core, DENSEPOSE_PROCESSOR_PATH, DENSEPOSE_PROCESSOR_INT4_PATH, group_size, ratio)
+    compress_model(core, SCHP_PROCESSOR_ATR, SCHP_PROCESSOR_ATR_INT4, group_size, ratio)
+    compress_model(core, SCHP_PROCESSOR_LIP, SCHP_PROCESSOR_LIP_INT4, group_size, ratio)
+
+
+def compare_models_size():
+    fp16_model_paths = [
+        VAE_ENCODER_PATH,
+        VAE_DECODER_PATH,
+        UNET_PATH,
+        DENSEPOSE_PROCESSOR_PATH,
+        SCHP_PROCESSOR_ATR,
+        SCHP_PROCESSOR_LIP,
+    ]
+    optimized_models = [
+        VAE_ENCODER_INT4_PATH,
+        VAE_DECODER_INT4_PATH,
+        UNET_INT8_PATH,
+        DENSEPOSE_PROCESSOR_INT4_PATH,
+        SCHP_PROCESSOR_ATR_INT4,
+        SCHP_PROCESSOR_LIP_INT4,
+    ]
+
+    for fp16_path, optimized_path in zip(fp16_model_paths, optimized_models):
+        if not fp16_path.exists():
+            continue
+        fp16_ir_model_size = fp16_path.with_suffix(".bin").stat().st_size
+        optimized_model_size = optimized_path.with_suffix(".bin").stat().st_size
+        print(f"{fp16_path.stem} compression rate: {fp16_ir_model_size / optimized_model_size:.3f}")

catvton_workflow.json

@@ -0,0 +1,477 @@
+{
+  "last_node_id": 23,
+  "last_link_id": 27,
+  "nodes": [
+    {
+      "id": 12,
+      "type": "LoadAutoMasker",
+      "pos": [
+        97,
+        118
+      ],
+      "size": {
+        "0": 436.1082458496094,
+        "1": 58
+      },
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "pipe",
+          "type": "MODEL",
+          "links": [
+            11
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LoadAutoMasker"
+      },
+      "widgets_values": [
+        "zhengchong/CatVTON"
+      ]
+    },
+    {
+      "id": 14,
+      "type": "PreviewImage",
+      "pos": [
+        1028,
+        115
+      ],
+      "size": {
+        "0": 160.99398803710938,
+        "1": 246
+      },
+      "flags": {},
+      "order": 7,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 17
+        }
+      ],
+      "title": "Masked Target",
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 18,
+      "type": "PreviewImage",
+      "pos": [
+        879,
+        469
+      ],
+      "size": {
+        "0": 313.9939880371094,
+        "1": 341.0123291015625
+      },
+      "flags": {},
+      "order": 8,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 27
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 11,
+      "type": "LoadImage",
+      "pos": [
+        319.77685748644126,
+        463.34710718580516
+      ],
+      "size": {
+        "0": 210,
+        "1": 347.0123291015625
+      },
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            15
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "title": "Reference Garment",
+      "properties": {
+        "Node name for S&R": "LoadImage"
+      },
+      "widgets_values": [
+        "1300-28.jpg",
+        "image"
+      ],
+      "shape": 2
+    },
+    {
+      "id": 16,
+      "type": "CatVTON",
+      "pos": [
+        599,
+        471
+      ],
+      "size": {
+        "0": 242.99398803710938,
+        "1": 338.0123291015625
+      },
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "pipe",
+          "type": "MODEL",
+          "link": 20
+        },
+        {
+          "name": "target_image",
+          "type": "IMAGE",
+          "link": 14
+        },
+        {
+          "name": "refer_image",
+          "type": "IMAGE",
+          "link": 15
+        },
+        {
+          "name": "mask_image",
+          "type": "IMAGE",
+          "link": 19
+        }
+      ],
+      "outputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "links": [
+            27
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CatVTON"
+      },
+      "widgets_values": [
+        42,
+        "fixed",
+        50,
+        2.5
+      ]
+    },
+    {
+      "id": 10,
+      "type": "LoadImage",
+      "pos": [
+        93.77685748644114,
+        465.34710718580516
+      ],
+      "size": {
+        "0": 210,
+        "1": 345.0123291015625
+      },
+      "flags": {
+        "pinned": false
+      },
+      "order": 2,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            10,
+            14
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": null,
+          "shape": 3,
+          "slot_index": 1
+        }
+      ],
+      "title": "Target Person",
+      "properties": {
+        "Node name for S&R": "LoadImage"
+      },
+      "widgets_values": [
+        "1300.jpg",
+        "image"
+      ],
+      "shape": 2
+    },
+    {
+      "id": 15,
+      "type": "PreviewImage",
+      "pos": [
+        845,
+        116
+      ],
+      "size": {
+        "0": 160.1082305908203,
+        "1": 246
+      },
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 18
+        }
+      ],
+      "title": "Binary Mask",
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 13,
+      "type": "AutoMasker",
+      "pos": [
+        593,
+        116
+      ],
+      "size": [
+        227.49812396694324,
+        240.48341801652845
+      ],
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "pipe",
+          "type": "MODEL",
+          "link": 11
+        },
+        {
+          "name": "target_image",
+          "type": "IMAGE",
+          "link": 10
+        }
+      ],
+      "outputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "links": [
+            18,
+            19
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "image_masked",
+          "type": "IMAGE",
+          "links": [
+            17
+          ],
+          "shape": 3,
+          "slot_index": 1
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "AutoMasker"
+      },
+      "widgets_values": [
+        "overall"
+      ]
+    },
+    {
+      "id": 17,
+      "type": "LoadCatVTONPipeline",
+      "pos": [
+        101,
+        223
+      ],
+      "size": {
+        "0": 431.00823974609375,
+        "1": 106
+      },
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "pipe",
+          "type": "MODEL",
+          "links": [
+            20
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LoadCatVTONPipeline"
+      },
+      "widgets_values": [
+        "runwayml/stable-diffusion-inpainting",
+        "zhengchong/CatVTON",
+        "bf16"
+      ]
+    }
+  ],
+  "links": [
+    [
+      10,
+      10,
+      0,
+      13,
+      1,
+      "IMAGE"
+    ],
+    [
+      11,
+      12,
+      0,
+      13,
+      0,
+      "MODEL"
+    ],
+    [
+      14,
+      10,
+      0,
+      16,
+      1,
+      "IMAGE"
+    ],
+    [
+      15,
+      11,
+      0,
+      16,
+      2,
+      "IMAGE"
+    ],
+    [
+      17,
+      13,
+      1,
+      14,
+      0,
+      "IMAGE"
+    ],
+    [
+      18,
+      13,
+      0,
+      15,
+      0,
+      "IMAGE"
+    ],
+    [
+      19,
+      13,
+      0,
+      16,
+      3,
+      "IMAGE"
+    ],
+    [
+      20,
+      17,
+      0,
+      16,
+      0,
+      "MODEL"
+    ],
+    [
+      27,
+      16,
+      0,
+      18,
+      0,
+      "IMAGE"
+    ]
+  ],
+  "groups": [
+    {
+      "title": "Model Loading",
+      "bounding": [
+        80,
+        38,
+        480,
+        333
+      ],
+      "color": "#b06634",
+      "font_size": 24
+    },
+    {
+      "title": "Auto Mask Generating",
+      "bounding": [
+        579,
+        37,
+        630,
+        339
+      ],
+      "color": "#8AA",
+      "font_size": 24
+    },
+    {
+      "title": "Inputs Image",
+      "bounding": [
+        80,
+        384,
+        483,
+        443
+      ],
+      "color": "#3f789e",
+      "font_size": 24
+    },
+    {
+      "title": "TryOn by CatVTON",
+      "bounding": [
+        580,
+        387,
+        629,
+        441
+      ],
+      "color": "#b58b2a",
+      "font_size": 24
+    }
+  ],
+  "config": {},
+  "extra": {
+    "ds": {
+      "scale": 1.2100000000000002,
+      "offset": [
+        206.77460330578393,
+        291.45046628099226
+      ]
+    }
+  },
+  "version": 0.4
+}

gradio_helper.py

@@ -0,0 +1,188 @@
+import argparse
+import os
+from datetime import datetime
+
+import gradio as gr
+import numpy as np
+import torch
+from PIL import Image
+
+from model.cloth_masker import vis_mask
+from utils import init_weight_dtype, resize_and_crop, resize_and_padding
+
+
+def image_grid(imgs, rows, cols):
+    assert len(imgs) == rows * cols
+
+    w, h = imgs[0].size
+    grid = Image.new("RGB", size=(cols * w, rows * h))
+
+    for i, img in enumerate(imgs):
+        grid.paste(img, box=(i % cols * w, i // cols * h))
+    return grid
+
+
+HEADER = """
+<h1 style="text-align: center;"> 🐈 CatVTON: Concatenation Is All You Need for Virtual Try-On with Diffusion Models </h1>
+"""
+
+
+def make_demo(pipeline, mask_processor, automasker, output_dir):
+    def submit_function(person_image, cloth_image, cloth_type, num_inference_steps, guidance_scale, seed, show_type):
+        width = 768
+        height = 1024
+        person_image, mask = person_image["background"], person_image["layers"][0]
+        mask = Image.open(mask).convert("L")
+        if len(np.unique(np.array(mask))) == 1:
+            mask = None
+        else:
+            mask = np.array(mask)
+            mask[mask > 0] = 255
+            mask = Image.fromarray(mask)
+
+        tmp_folder = output_dir
+        date_str = datetime.now().strftime("%Y%m%d%H%M%S")
+        result_save_path = os.path.join(tmp_folder, date_str[:8], date_str[8:] + ".png")
+        if not os.path.exists(os.path.join(tmp_folder, date_str[:8])):
+            os.makedirs(os.path.join(tmp_folder, date_str[:8]))
+
+        generator = None
+        if seed != -1:
+            generator = torch.Generator(device="cpu").manual_seed(seed)
+
+        person_image = Image.open(person_image).convert("RGB")
+        cloth_image = Image.open(cloth_image).convert("RGB")
+        person_image = resize_and_crop(person_image, (width, height))
+        cloth_image = resize_and_padding(cloth_image, (width, height))
+
+        # Process mask
+        if mask is not None:
+            mask = resize_and_crop(mask, (width, height))
+        else:
+            mask = automasker(person_image, cloth_type)["mask"]
+        mask = mask_processor.blur(mask, blur_factor=9)
+
+        # Inference
+        result_image = pipeline(
+            image=person_image,
+            condition_image=cloth_image,
+            mask=mask,
+            num_inference_steps=num_inference_steps,
+            guidance_scale=guidance_scale,
+            generator=generator,
+        )[0]
+
+        # Post-process
+        masked_person = vis_mask(person_image, mask)
+        save_result_image = image_grid([person_image, masked_person, cloth_image, result_image], 1, 4)
+        save_result_image.save(result_save_path)
+        if show_type == "result only":
+            return result_image
+        else:
+            width, height = person_image.size
+            if show_type == "input & result":
+                condition_width = width // 2
+                conditions = image_grid([person_image, cloth_image], 2, 1)
+            else:
+                condition_width = width // 3
+                conditions = image_grid([person_image, masked_person, cloth_image], 3, 1)
+            conditions = conditions.resize((condition_width, height), Image.NEAREST)
+            new_result_image = Image.new("RGB", (width + condition_width + 5, height))
+            new_result_image.paste(conditions, (0, 0))
+            new_result_image.paste(result_image, (condition_width + 5, 0))
+        return new_result_image
+
+    with gr.Blocks(title="CatVTON") as demo:
+        gr.Markdown(HEADER)
+        with gr.Row():
+            with gr.Column(scale=1, min_width=350):
+                with gr.Row():
+                    person_image = gr.ImageEditor(interactive=True, label="Person Image", type="filepath")
+
+                with gr.Row():
+                    with gr.Column(scale=1, min_width=230):
+                        cloth_image = gr.Image(interactive=True, label="Condition Image", type="filepath")
+                    with gr.Column(scale=1, min_width=120):
+                        gr.Markdown(
+                            '<span style="color: #808080; font-size: small;">Two ways to provide Mask:<br>1. Upload the person image and use the `🖌️` above to draw the Mask (higher priority)<br>2. Select the `Try-On Cloth Type` to generate automatically </span>'
+                        )
+                        cloth_type = gr.Radio(
+                            label="Try-On Cloth Type",
+                            choices=["upper", "lower", "overall"],
+                            value="upper",
+                        )
+
+                submit = gr.Button("Submit")
+
+                gr.Markdown(
+                    '<span style="color: #808080; font-size: small;">Advanced options can adjust details:<br>1. `Inference Step` may enhance details;<br>2. `CFG` is highly correlated with saturation;<br>3. `Random seed` may improve pseudo-shadow.</span>'
+                )
+                with gr.Accordion("Advanced Options", open=False):
+                    num_inference_steps = gr.Slider(label="Inference Step", minimum=10, maximum=100, step=5, value=50)
+                    # Guidence Scale
+                    guidance_scale = gr.Slider(label="CFG Strenth", minimum=0.0, maximum=7.5, step=0.5, value=2.5)
+                    # Random Seed
+                    seed = gr.Slider(label="Seed", minimum=-1, maximum=10000, step=1, value=42)
+                    show_type = gr.Radio(
+                        label="Show Type",
+                        choices=["result only", "input & result", "input & mask & result"],
+                        value="input & mask & result",
+                    )
+
+            with gr.Column(scale=2, min_width=500):
+                result_image = gr.Image(interactive=False, label="Result")
+                with gr.Row():
+                    # Photo Examples
+                    root_path = "CatVTON/resource/demo/example"
+                    with gr.Column():
+                        men_exm = gr.Examples(
+                            examples=[os.path.join(root_path, "person", "men", _) for _ in os.listdir(os.path.join(root_path, "person", "men"))],
+                            examples_per_page=4,
+                            inputs=person_image,
+                            label="Person Examples ①",
+                        )
+                        women_exm = gr.Examples(
+                            examples=[os.path.join(root_path, "person", "women", _) for _ in os.listdir(os.path.join(root_path, "person", "women"))],
+                            examples_per_page=4,
+                            inputs=person_image,
+                            label="Person Examples ②",
+                        )
+                        gr.Markdown(
+                            '<span style="color: #808080; font-size: small;">*Person examples come from the demos of <a href="https://huggingface.co/spaces/levihsu/OOTDiffusion">OOTDiffusion</a> and <a href="https://www.outfitanyone.org">OutfitAnyone</a>. </span>'
+                        )
+                    with gr.Column():
+                        condition_upper_exm = gr.Examples(
+                            examples=[os.path.join(root_path, "condition", "upper", _) for _ in os.listdir(os.path.join(root_path, "condition", "upper"))],
+                            examples_per_page=4,
+                            inputs=cloth_image,
+                            label="Condition Upper Examples",
+                        )
+                        condition_overall_exm = gr.Examples(
+                            examples=[os.path.join(root_path, "condition", "overall", _) for _ in os.listdir(os.path.join(root_path, "condition", "overall"))],
+                            examples_per_page=4,
+                            inputs=cloth_image,
+                            label="Condition Overall Examples",
+                        )
+                        condition_person_exm = gr.Examples(
+                            examples=[os.path.join(root_path, "condition", "person", _) for _ in os.listdir(os.path.join(root_path, "condition", "person"))],
+                            examples_per_page=4,
+                            inputs=cloth_image,
+                            label="Condition Reference Person Examples",
+                        )
+                        gr.Markdown('<span style="color: #808080; font-size: small;">*Condition examples come from the Internet. </span>')
+
+            submit.click(
+                submit_function,
+                [
+                    person_image,
+                    cloth_image,
+                    cloth_type,
+                    num_inference_steps,
+                    guidance_scale,
+                    seed,
+                    show_type,
+                ],
+                result_image,
+            )
+
+    return demo

ov_catvton_helper.py

@@ -0,0 +1,244 @@
+import gc
+import os
+from collections import namedtuple
+from pathlib import Path
+import warnings
+
+from diffusers.image_processor import VaeImageProcessor
+from diffusers.models.autoencoders.vae import DiagonalGaussianDistribution
+from huggingface_hub import snapshot_download
+import yaml
+import openvino as ov
+import torch
+
+from model.cloth_masker import AutoMasker
+from model.pipeline import CatVTONPipeline
+
+MODEL_DIR = Path("models")
+VAE_ENCODER_PATH = MODEL_DIR / "vae_encoder.xml"
+VAE_DECODER_PATH = MODEL_DIR / "vae_decoder.xml"
+UNET_PATH = MODEL_DIR / "unet.xml"
+DENSEPOSE_PROCESSOR_PATH = MODEL_DIR / "densepose_processor.xml"
+SCHP_PROCESSOR_ATR = MODEL_DIR / "schp_processor_atr.xml"
+SCHP_PROCESSOR_LIP = MODEL_DIR / "schp_processor_lip.xml"
+
+
+def convert(model: torch.nn.Module, xml_path: str, example_input):
+    xml_path = Path(xml_path)
+    if not xml_path.exists():
+        xml_path.parent.mkdir(parents=True, exist_ok=True)
+        model.eval()
+        with torch.no_grad():
+            converted_model = ov.convert_model(model, example_input=example_input)
+        ov.save_model(converted_model, xml_path)
+
+        # cleanup memory
+        torch._C._jit_clear_class_registry()
+        torch.jit._recursive.concrete_type_store = torch.jit._recursive.ConcreteTypeStore()
+        torch.jit._state._clear_class_state()
+
+
+class VaeEncoder(torch.nn.Module):
+    def __init__(self, vae):
+        super().__init__()
+        self.vae = vae
+
+    def forward(self, x):
+        return {"latent_parameters": self.vae.encode(x)["latent_dist"].parameters}
+
+
+class VaeDecoder(torch.nn.Module):
+    def __init__(self, vae):
+        super().__init__()
+        self.vae = vae
+
+    def forward(self, latents):
+        return self.vae.decode(latents)
+
+
+class UNetWrapper(torch.nn.Module):
+    def __init__(self, unet):
+        super().__init__()
+        self.unet = unet
+
+    def forward(self, sample=None, timestep=None, encoder_hidden_states=None, return_dict=None):
+        result = self.unet(sample=sample, timestep=timestep, encoder_hidden_states=encoder_hidden_states, return_dict=False)
+        return result
+
+
+def download_models():
+    resume_path = "zhengchong/CatVTON"
+    base_model_path = "booksforcharlie/stable-diffusion-inpainting"
+    repo_path = snapshot_download(repo_id=resume_path, local_dir=MODEL_DIR)
+
+    pipeline = CatVTONPipeline(base_ckpt=base_model_path, attn_ckpt=repo_path, attn_ckpt_version="mix", use_tf32=True, device="cpu")
+
+    # fix default config to use cpu
+    with open(f"{repo_path}/DensePose/densepose_rcnn_R_50_FPN_s1x.yaml", "r") as fp:
+        data = yaml.safe_load(fp)
+
+    data["MODEL"].update({"DEVICE": "cpu"})
+
+    with open(f"{repo_path}/DensePose/densepose_rcnn_R_50_FPN_s1x.yaml", "w") as fp:
+        yaml.safe_dump(data, fp)
+
+    mask_processor = VaeImageProcessor(vae_scale_factor=8, do_normalize=False, do_binarize=True, do_convert_grayscale=True)
+    automasker = AutoMasker(
+        densepose_ckpt=os.path.join(repo_path, "DensePose"),
+        schp_ckpt=os.path.join(repo_path, "SCHP"),
+        device="cpu",
+    )
+    return pipeline, mask_processor, automasker
+
+
+def convert_pipeline_models(pipeline):
+    convert(VaeEncoder(pipeline.vae), VAE_ENCODER_PATH, torch.zeros(1, 3, 1024, 768))
+    convert(VaeDecoder(pipeline.vae), VAE_DECODER_PATH, torch.zeros(1, 4, 128, 96))
+    del pipeline.vae
+
+    inpainting_latent_model_input = torch.rand(2, 9, 256, 96)
+    timestep = torch.tensor(0)
+    encoder_hidden_states = torch.Tensor(0)
+    example_input = (inpainting_latent_model_input, timestep, encoder_hidden_states)
+
+    convert(UNetWrapper(pipeline.unet), UNET_PATH, example_input)
+    del pipeline.unet
+    gc.collect()
+
+
+def convert_automasker_models(automasker):
+    from detectron2.export import TracingAdapter  # it's detectron2 from CatVTON repo
+
+    def inference(model, inputs):
+        # use do_postprocess=False so it returns ROI mask
+        inst = model.inference(inputs, do_postprocess=False)[0]
+        return [{"instances": inst}]
+
+    tracing_input = [{"image": torch.rand([3, 800, 800], dtype=torch.float32)}]
+    warnings.filterwarnings("ignore")
+    traceable_model = TracingAdapter(automasker.densepose_processor.predictor.model, tracing_input, inference)
+
+    convert(traceable_model, DENSEPOSE_PROCESSOR_PATH, tracing_input[0]["image"])
+    del automasker.densepose_processor.predictor.model
+
+    convert(automasker.schp_processor_atr.model, SCHP_PROCESSOR_ATR, torch.rand([1, 3, 512, 512], dtype=torch.float32))
+    convert(automasker.schp_processor_lip.model, SCHP_PROCESSOR_LIP, torch.rand([1, 3, 473, 473], dtype=torch.float32))
+    del automasker.schp_processor_atr.model
+    del automasker.schp_processor_lip.model
+    gc.collect()
+
+
+class VAEWrapper(torch.nn.Module):
+    def __init__(self, vae_encoder, vae_decoder, scaling_factor):
+        super().__init__()
+        self.vae_enocder = vae_encoder
+        self.vae_decoder = vae_decoder
+        self.device = "cpu"
+        self.dtype = torch.float32
+        self.config = namedtuple("VAEConfig", ["scaling_factor"])(scaling_factor)
+
+    def encode(self, pixel_values):
+        ov_outputs = self.vae_enocder(pixel_values).to_dict()
+
+        model_outputs = {}
+        for key, value in ov_outputs.items():
+            model_outputs[next(iter(key.names))] = torch.from_numpy(value)
+
+        result = namedtuple("VAE", "latent_dist")(DiagonalGaussianDistribution(parameters=model_outputs.pop("latent_parameters")))
+
+        return result
+
+    def decode(self, latents):
+        outs = self.vae_decoder(latents)
+        outs = namedtuple("VAE", "sample")(torch.from_numpy(outs[0]))
+        return outs
+
+
+class ConvUnetWrapper(torch.nn.Module):
+    def __init__(self, unet):
+        super().__init__()
+        self.unet = unet
+
+    def forward(self, sample, timestep, encoder_hidden_states=None, **kwargs):
+        outputs = self.unet(
+            {
+                "sample": sample,
+                "timestep": timestep,
+            },
+        )
+
+        return [torch.from_numpy(outputs[0])]
+
+
+class ConvDenseposeProcessorWrapper(torch.nn.Module):
+    def __init__(self, densepose_processor):
+        super().__init__()
+        self.densepose_processor = densepose_processor
+
+    def forward(self, sample, **kwargs):
+        from detectron2.structures import Instances, Boxes  # it's detectron2 from CatVTON repo
+
+        outputs = self.densepose_processor(sample[0]["image"])
+        boxes = outputs[0]
+        classes = outputs[1]
+        has_mask = len(outputs) >= 5
+        scores = outputs[2 if not has_mask else 3]
+        print(scores)
+        model_input_size = (
+            int(outputs[3 if not has_mask else 4][0]),
+            int(outputs[3 if not has_mask else 4][1]),
+        )
+        filtered_detections = scores >= 0
+        boxes = Boxes(boxes[filtered_detections])
+        scores = scores[filtered_detections]
+        classes = classes[filtered_detections]
+        out_dict = {"pred_boxes": boxes, "scores": scores, "pred_classes": classes}
+
+        instances = Instances(model_input_size, **out_dict)
+
+        return [{"instances": instances}]
+
+
+class ConvSchpProcessorWrapper(torch.nn.Module):
+    def __init__(self, schp_processor):
+        super().__init__()
+        self.schp_processor = schp_processor
+
+    def forward(self, image):
+        outputs = self.schp_processor(image)
+
+        return torch.from_numpy(outputs[0])
+
+
+def get_compiled_pipeline(pipeline, core, device, vae_encoder_path, vae_decoder_path, unet_path, vae_scaling_factor):
+    compiled_unet = core.compile_model(unet_path, device.value)
+    compiled_vae_encoder = core.compile_model(vae_encoder_path, device.value)
+    compiled_vae_decoder = core.compile_model(vae_decoder_path, device.value)
+
+    pipeline.vae = VAEWrapper(compiled_vae_encoder, compiled_vae_decoder, vae_scaling_factor)
+    pipeline.unet = ConvUnetWrapper(compiled_unet)
+
+    return pipeline
+
+
+def get_compiled_automasker(automasker, core, device, densepose_processor_path, schp_processor_atr_path, schp_processor_lip_path):
+    compiled_densepose_processor = core.compile_model(densepose_processor_path, device.value)
+    compiled_schp_processor_atr = core.compile_model(schp_processor_atr_path, device.value)
+    compiled_schp_processor_lip = core.compile_model(schp_processor_lip_path, device.value)
+
+    automasker.densepose_processor.predictor.model = ConvDenseposeProcessorWrapper(compiled_densepose_processor)
+    automasker.schp_processor_atr.model = ConvSchpProcessorWrapper(compiled_schp_processor_atr)
+    automasker.schp_processor_lip.model = ConvSchpProcessorWrapper(compiled_schp_processor_lip)
+
+    return automasker
+
+
+def get_pipeline_selection_option(is_optimized_pipe_available=False):
+    import ipywidgets as widgets
+
+    use_quantized_models = widgets.Checkbox(
+        value=is_optimized_pipe_available,
+        description="Use quantized models",
+        disabled=not is_optimized_pipe_available,
+    )
+    return use_quantized_models