Initial Commit

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+ckpt/** filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,180 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+venv
+models
+.vs/
+outputs
+temp_faces
+loras
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+.vscode/
+*.pyc
+
+#others
+outputs/
+__pycache__/
+densepose/__pycache__/
+detectron2/__pycache__/
+ip_adapter/__pycache__/
+preprocess/humanparsing/__pycache__/
+preprocess/openpose/__pycache__/
+util/__pycache__/
+src/__pycache__/

README.md

@@ -1,12 +1,162 @@
+
+<div align="center">
+<h1>IDM-VTON: Improving Diffusion Models for Authentic Virtual Try-on in the Wild</h1>
+
+<a href='https://idm-vton.github.io'><img src='https://img.shields.io/badge/Project-Page-green'></a>
+<a href='https://arxiv.org/abs/2403.05139'><img src='https://img.shields.io/badge/Paper-Arxiv-red'></a>
+<a href='https://huggingface.co/spaces/yisol/IDM-VTON'><img src='https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Demo-blue'></a>
+<a href='https://huggingface.co/yisol/IDM-VTON'><img src='https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Model-blue'></a>
+
+
+</div>
+
+This is the official implementation of the paper ["Improving Diffusion Models for Authentic Virtual Try-on in the Wild"](https://arxiv.org/abs/2403.05139).
+
+Star ⭐ us if you like it!
+
 ---
-title: Ailusion VTON DEMO V1
-emoji: 👁
-colorFrom: red
-colorTo: indigo
-sdk: gradio
-sdk_version: 4.31.2
-app_file: app.py
-pinned: false
----
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+![teaser2](assets/teaser2.png)&nbsp;
+![teaser](assets/teaser.png)&nbsp;
+
+
+## TODO LIST
+
+
+- [x] demo model
+- [x] inference code
+- [ ] training code
+
+
+
+## Requirements
+
+```
+git clone https://github.com/yisol/IDM-VTON.git
+cd IDM-VTON
+
+conda env create -f environment.yaml
+conda activate idm
+```
+
+## Data preparation
+
+### VITON-HD
+You can download VITON-HD dataset from [VITON-HD](https://github.com/shadow2496/VITON-HD).
+
+After download VITON-HD dataset, move vitonhd_test_tagged.json into the test folder.
+
+Structure of the Dataset directory should be as follows.
+
+```
+
+train
+|-- ...
+
+test
+|-- image
+|-- image-densepose
+|-- agnostic-mask
+|-- cloth
+|-- vitonhd_test_tagged.json
+
+```
+
+### DressCode
+You can download DressCode dataset from [DressCode](https://github.com/aimagelab/dress-code).
+
+We provide pre-computed densepose images and captions for garments [here](https://kaistackr-my.sharepoint.com/:u:/g/personal/cpis7_kaist_ac_kr/EaIPRG-aiRRIopz9i002FOwBDa-0-BHUKVZ7Ia5yAVVG3A?e=YxkAip).
+
+We used [detectron2](https://github.com/facebookresearch/detectron2) for obtaining densepose images, refer [here](https://github.com/sangyun884/HR-VITON/issues/45) for more details.
+
+After download the DressCode dataset, place image-densepose directories and caption text files as follows.
+
+```
+DressCode
+|-- dresses
+    |-- images
+    |-- image-densepose
+    |-- dc_caption.txt
+    |-- ...
+|-- lower_body
+    |-- images
+    |-- image-densepose
+    |-- dc_caption.txt
+    |-- ...
+|-- upper_body
+    |-- images
+    |-- image-densepose
+    |-- dc_caption.txt
+    |-- ...
+```
+
+
+## Inference
+
+
+### VITON-HD
+
+Inference using python file with arguments,
+
+```
+accelerate launch inference.py \
+    --width 768 --height 1024 --num_inference_steps 30 \
+    --output_dir "result" \
+    --unpaired \
+    --data_dir "DATA_DIR" \
+    --seed 42 \
+    --test_batch_size 2 \
+    --guidance_scale 2.0
+```
+
+or, you can simply run with the script file.
+
+```
+sh inference.sh
+```
+
+### DressCode
+
+For DressCode dataset, put the category you want to generate images via category argument,
+```
+accelerate launch inference_dc.py \
+    --width 768 --height 1024 --num_inference_steps 30 \
+    --output_dir "result" \
+    --unpaired \
+    --data_dir "DATA_DIR" \
+    --seed 42 
+    --test_batch_size 2
+    --guidance_scale 2.0
+    --category "upper_body" 
+```
+
+or, you can simply run with the script file.
+```
+sh inference.sh
+```
+
+
+## Acknowledgements
+
+For the [demo](https://huggingface.co/spaces/yisol/IDM-VTON), GPUs are supported from [ZeroGPU](https://huggingface.co/zero-gpu-explorers), and masking generation codes are based on [OOTDiffusion](https://github.com/levihsu/OOTDiffusion) and [DCI-VTON](https://github.com/bcmi/DCI-VTON-Virtual-Try-On).
+
+Parts of our code are based on [IP-Adapter](https://github.com/tencent-ailab/IP-Adapter).
+
+
+
+## Citation
+```
+@article{choi2024improving,
+  title={Improving Diffusion Models for Virtual Try-on},
+  author={Choi, Yisol and Kwak, Sangkyung and Lee, Kyungmin and Choi, Hyungwon and Shin, Jinwoo},
+  journal={arXiv preprint arXiv:2403.05139},
+  year={2024}
+}
+```
+
+## License
+The codes and checkpoints in this repository are under the [CC BY-NC-SA 4.0 license](https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode).
+
+
+

app.py

@@ -0,0 +1,313 @@
+import gradio as gr
+from PIL import Image
+from src.tryon_pipeline import StableDiffusionXLInpaintPipeline as TryonPipeline
+from src.unet_hacked_garmnet import UNet2DConditionModel as UNet2DConditionModel_ref
+from src.unet_hacked_tryon import UNet2DConditionModel
+from transformers import (
+    CLIPImageProcessor,
+    CLIPVisionModelWithProjection,
+    CLIPTextModel,
+    CLIPTextModelWithProjection,
+)
+from diffusers import DDPMScheduler,AutoencoderKL
+from typing import List
+
+import torch
+import os
+from transformers import AutoTokenizer
+import spaces
+import numpy as np
+from utils_mask import get_mask_location
+from torchvision import transforms
+import apply_net
+from preprocess.humanparsing.run_parsing import Parsing
+from preprocess.openpose.run_openpose import OpenPose
+from detectron2.data.detection_utils import convert_PIL_to_numpy,_apply_exif_orientation
+from torchvision.transforms.functional import to_pil_image
+
+
+def pil_to_binary_mask(pil_image, threshold=0):
+    np_image = np.array(pil_image)
+    grayscale_image = Image.fromarray(np_image).convert("L")
+    binary_mask = np.array(grayscale_image) > threshold
+    mask = np.zeros(binary_mask.shape, dtype=np.uint8)
+    for i in range(binary_mask.shape[0]):
+        for j in range(binary_mask.shape[1]):
+            if binary_mask[i,j] == True :
+                mask[i,j] = 1
+    mask = (mask*255).astype(np.uint8)
+    output_mask = Image.fromarray(mask)
+    return output_mask
+
+
+base_path = 'yisol/IDM-VTON'
+example_path = os.path.join(os.path.dirname(__file__), 'example')
+
+unet = UNet2DConditionModel.from_pretrained(
+    base_path,
+    subfolder="unet",
+    torch_dtype=torch.float16,
+)
+unet.requires_grad_(False)
+tokenizer_one = AutoTokenizer.from_pretrained(
+    base_path,
+    subfolder="tokenizer",
+    revision=None,
+    use_fast=False,
+)
+tokenizer_two = AutoTokenizer.from_pretrained(
+    base_path,
+    subfolder="tokenizer_2",
+    revision=None,
+    use_fast=False,
+)
+noise_scheduler = DDPMScheduler.from_pretrained(base_path, subfolder="scheduler")
+
+text_encoder_one = CLIPTextModel.from_pretrained(
+    base_path,
+    subfolder="text_encoder",
+    torch_dtype=torch.float16,
+)
+text_encoder_two = CLIPTextModelWithProjection.from_pretrained(
+    base_path,
+    subfolder="text_encoder_2",
+    torch_dtype=torch.float16,
+)
+image_encoder = CLIPVisionModelWithProjection.from_pretrained(
+    base_path,
+    subfolder="image_encoder",
+    torch_dtype=torch.float16,
+    )
+vae = AutoencoderKL.from_pretrained(base_path,
+                                    subfolder="vae",
+                                    torch_dtype=torch.float16,
+)
+
+# "stabilityai/stable-diffusion-xl-base-1.0",
+UNet_Encoder = UNet2DConditionModel_ref.from_pretrained(
+    base_path,
+    subfolder="unet_encoder",
+    torch_dtype=torch.float16,
+)
+
+parsing_model = Parsing(0)
+openpose_model = OpenPose(0)
+
+UNet_Encoder.requires_grad_(False)
+image_encoder.requires_grad_(False)
+vae.requires_grad_(False)
+unet.requires_grad_(False)
+text_encoder_one.requires_grad_(False)
+text_encoder_two.requires_grad_(False)
+tensor_transfrom = transforms.Compose(
+            [
+                transforms.ToTensor(),
+                transforms.Normalize([0.5], [0.5]),
+            ]
+    )
+
+pipe = TryonPipeline.from_pretrained(
+        base_path,
+        unet=unet,
+        vae=vae,
+        feature_extractor= CLIPImageProcessor(),
+        text_encoder = text_encoder_one,
+        text_encoder_2 = text_encoder_two,
+        tokenizer = tokenizer_one,
+        tokenizer_2 = tokenizer_two,
+        scheduler = noise_scheduler,
+        image_encoder=image_encoder,
+        torch_dtype=torch.float16,
+)
+pipe.unet_encoder = UNet_Encoder
+
+@spaces.GPU
+def start_tryon(dict,garm_img,garment_des,is_checked,is_checked_crop,denoise_steps,seed):
+    device = "cuda"
+    
+    openpose_model.preprocessor.body_estimation.model.to(device)
+    pipe.to(device)
+    pipe.unet_encoder.to(device)
+
+    garm_img= garm_img.convert("RGB").resize((768,1024))
+    human_img_orig = dict["background"].convert("RGB")    
+    
+    if is_checked_crop:
+        width, height = human_img_orig.size
+        target_width = int(min(width, height * (3 / 4)))
+        target_height = int(min(height, width * (4 / 3)))
+        left = (width - target_width) / 2
+        top = (height - target_height) / 2
+        right = (width + target_width) / 2
+        bottom = (height + target_height) / 2
+        cropped_img = human_img_orig.crop((left, top, right, bottom))
+        crop_size = cropped_img.size
+        human_img = cropped_img.resize((768,1024))
+    else:
+        human_img = human_img_orig.resize((768,1024))
+
+
+    if is_checked:
+        keypoints = openpose_model(human_img.resize((384,512)))
+        model_parse, _ = parsing_model(human_img.resize((384,512)))
+        mask, mask_gray = get_mask_location('hd', "upper_body", model_parse, keypoints)
+        mask = mask.resize((768,1024))
+    else:
+        mask = pil_to_binary_mask(dict['layers'][0].convert("RGB").resize((768, 1024)))
+        # mask = transforms.ToTensor()(mask)
+        # mask = mask.unsqueeze(0)
+    mask_gray = (1-transforms.ToTensor()(mask)) * tensor_transfrom(human_img)
+    mask_gray = to_pil_image((mask_gray+1.0)/2.0)
+
+
+    human_img_arg = _apply_exif_orientation(human_img.resize((384,512)))
+    human_img_arg = convert_PIL_to_numpy(human_img_arg, format="BGR")
+     
+    
+
+    args = apply_net.create_argument_parser().parse_args(('show', './configs/densepose_rcnn_R_50_FPN_s1x.yaml', './ckpt/densepose/model_final_162be9.pkl', 'dp_segm', '-v', '--opts', 'MODEL.DEVICE', 'cuda'))
+    # verbosity = getattr(args, "verbosity", None)
+    pose_img = args.func(args,human_img_arg)    
+    pose_img = pose_img[:,:,::-1]    
+    pose_img = Image.fromarray(pose_img).resize((768,1024))
+    
+    with torch.no_grad():
+        # Extract the images
+        with torch.cuda.amp.autocast():
+            with torch.no_grad():
+                prompt = "model is wearing " + garment_des
+                negative_prompt = "monochrome, lowres, bad anatomy, worst quality, low quality"
+                with torch.inference_mode():
+                    (
+                        prompt_embeds,
+                        negative_prompt_embeds,
+                        pooled_prompt_embeds,
+                        negative_pooled_prompt_embeds,
+                    ) = pipe.encode_prompt(
+                        prompt,
+                        num_images_per_prompt=1,
+                        do_classifier_free_guidance=True,
+                        negative_prompt=negative_prompt,
+                    )
+                                    
+                    prompt = "a photo of " + garment_des
+                    negative_prompt = "monochrome, lowres, bad anatomy, worst quality, low quality"
+                    if not isinstance(prompt, List):
+                        prompt = [prompt] * 1
+                    if not isinstance(negative_prompt, List):
+                        negative_prompt = [negative_prompt] * 1
+                    with torch.inference_mode():
+                        (
+                            prompt_embeds_c,
+                            _,
+                            _,
+                            _,
+                        ) = pipe.encode_prompt(
+                            prompt,
+                            num_images_per_prompt=1,
+                            do_classifier_free_guidance=False,
+                            negative_prompt=negative_prompt,
+                        )
+
+
+
+                    pose_img =  tensor_transfrom(pose_img).unsqueeze(0).to(device,torch.float16)
+                    garm_tensor =  tensor_transfrom(garm_img).unsqueeze(0).to(device,torch.float16)
+                    generator = torch.Generator(device).manual_seed(seed) if seed is not None else None
+                    images = pipe(
+                        prompt_embeds=prompt_embeds.to(device,torch.float16),
+                        negative_prompt_embeds=negative_prompt_embeds.to(device,torch.float16),
+                        pooled_prompt_embeds=pooled_prompt_embeds.to(device,torch.float16),
+                        negative_pooled_prompt_embeds=negative_pooled_prompt_embeds.to(device,torch.float16),
+                        num_inference_steps=denoise_steps,
+                        generator=generator,
+                        strength = 1.0,
+                        pose_img = pose_img.to(device,torch.float16),
+                        text_embeds_cloth=prompt_embeds_c.to(device,torch.float16),
+                        cloth = garm_tensor.to(device,torch.float16),
+                        mask_image=mask,
+                        image=human_img, 
+                        height=1024,
+                        width=768,
+                        ip_adapter_image = garm_img.resize((768,1024)),
+                        guidance_scale=2.0,
+                    )[0]
+
+    if is_checked_crop:
+        out_img = images[0].resize(crop_size)        
+        human_img_orig.paste(out_img, (int(left), int(top)))    
+        return human_img_orig, mask_gray
+    else:
+        return images[0], mask_gray
+    # return images[0], mask_gray
+
+garm_list = os.listdir(os.path.join(example_path,"cloth"))
+garm_list_path = [os.path.join(example_path,"cloth",garm) for garm in garm_list]
+
+human_list = os.listdir(os.path.join(example_path,"human"))
+human_list_path = [os.path.join(example_path,"human",human) for human in human_list]
+
+human_ex_list = []
+for ex_human in human_list_path:
+    ex_dict= {}
+    ex_dict['background'] = ex_human
+    ex_dict['layers'] = None
+    ex_dict['composite'] = None
+    human_ex_list.append(ex_dict)
+
+##default human
+
+
+image_blocks = gr.Blocks().queue()
+with image_blocks as demo:
+    gr.Markdown("## IDM-VTON 👕👔👚")
+    gr.Markdown("Virtual Try-on with your image and garment image. Check out the [source codes](https://github.com/yisol/IDM-VTON) and the [model](https://huggingface.co/yisol/IDM-VTON)")
+    with gr.Row():
+        with gr.Column():
+            imgs = gr.ImageEditor(sources='upload', type="pil", label='Human. Mask with pen or use auto-masking', interactive=True)
+            with gr.Row():
+                is_checked = gr.Checkbox(label="Yes", info="Use auto-generated mask (Takes 5 seconds)",value=True)
+            with gr.Row():
+                is_checked_crop = gr.Checkbox(label="Yes", info="Use auto-crop & resizing",value=False)
+
+            example = gr.Examples(
+                inputs=imgs,
+                examples_per_page=10,
+                examples=human_ex_list
+            )
+
+        with gr.Column():
+            garm_img = gr.Image(label="Garment", sources='upload', type="pil")
+            with gr.Row(elem_id="prompt-container"):
+                with gr.Row():
+                    prompt = gr.Textbox(placeholder="Description of garment ex) Short Sleeve Round Neck T-shirts", show_label=False, elem_id="prompt")
+            example = gr.Examples(
+                inputs=garm_img,
+                examples_per_page=8,
+                examples=garm_list_path)
+        with gr.Column():
+            # image_out = gr.Image(label="Output", elem_id="output-img", height=400)
+            masked_img = gr.Image(label="Masked image output", elem_id="masked-img",show_share_button=False)
+        with gr.Column():
+            # image_out = gr.Image(label="Output", elem_id="output-img", height=400)
+            image_out = gr.Image(label="Output", elem_id="output-img",show_share_button=False)
+
+
+
+
+    with gr.Column():
+        try_button = gr.Button(value="Try-on")
+        with gr.Accordion(label="Advanced Settings", open=False):
+            with gr.Row():
+                denoise_steps = gr.Number(label="Denoising Steps", minimum=20, maximum=40, value=30, step=1)
+                seed = gr.Number(label="Seed", minimum=-1, maximum=2147483647, step=1, value=42)
+
+
+
+    try_button.click(fn=start_tryon, inputs=[imgs, garm_img, prompt, is_checked,is_checked_crop, denoise_steps, seed], outputs=[image_out,masked_img], api_name='tryon')
+
+            
+
+
+image_blocks.launch()
+

app_VTON.py

@@ -0,0 +1,328 @@
+import gradio as gr
+import argparse, torch, os
+from PIL import Image
+from src.tryon_pipeline import StableDiffusionXLInpaintPipeline as TryonPipeline
+from src.unet_hacked_garmnet import UNet2DConditionModel as UNet2DConditionModel_ref
+from src.unet_hacked_tryon import UNet2DConditionModel
+from transformers import (
+    CLIPImageProcessor,
+    CLIPVisionModelWithProjection,
+)
+from diffusers import AutoencoderKL
+from typing import List
+from util.common import open_folder
+from util.image import pil_to_binary_mask, save_output_image
+from utils_mask import get_mask_location
+from torchvision import transforms
+import apply_net
+from preprocess.humanparsing.run_parsing import Parsing
+from preprocess.openpose.run_openpose import OpenPose
+from detectron2.data.detection_utils import convert_PIL_to_numpy,_apply_exif_orientation
+from torchvision.transforms.functional import to_pil_image
+from util.pipeline import quantize_4bit, restart_cpu_offload, torch_gc
+
+parser = argparse.ArgumentParser()
+parser.add_argument("--share", type=str, default=False, help="Set to True to share the app publicly.")
+parser.add_argument("--lowvram", action="store_true", help="Enable CPU offload for model operations.")
+parser.add_argument("--load_mode", default=None, type=str, choices=["4bit", "8bit"], help="Quantization mode for optimization memory consumption")
+parser.add_argument("--fixed_vae", action="store_true", default=True,  help="Use fixed vae for FP16.")
+args = parser.parse_args()
+
+load_mode = args.load_mode
+fixed_vae = args.fixed_vae
+
+dtype = torch.float16
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+model_id = 'yisol/IDM-VTON'
+vae_model_id = 'madebyollin/sdxl-vae-fp16-fix'
+
+dtypeQuantize = dtype
+
+if(load_mode in ('4bit','8bit')):
+    dtypeQuantize = torch.float8_e4m3fn
+
+ENABLE_CPU_OFFLOAD = args.lowvram
+torch.backends.cudnn.allow_tf32 = False
+torch.backends.cuda.allow_tf32 = False
+need_restart_cpu_offloading = False
+
+unet = None
+pipe = None
+UNet_Encoder = None
+example_path = os.path.join(os.path.dirname(__file__), 'example')
+
+def start_tryon(dict, garm_img, garment_des, category, is_checked, is_checked_crop, denoise_steps, is_randomize_seed, seed, number_of_images):
+    global pipe, unet, UNet_Encoder, need_restart_cpu_offloading
+
+    if pipe == None:
+        unet = UNet2DConditionModel.from_pretrained(
+            model_id,
+            subfolder="unet",
+            torch_dtype=dtypeQuantize,
+        )
+        if load_mode == '4bit':
+            quantize_4bit(unet)
+            
+        unet.requires_grad_(False)
+       
+        image_encoder = CLIPVisionModelWithProjection.from_pretrained(
+            model_id,
+            subfolder="image_encoder",
+            torch_dtype=torch.float16,
+            )
+        if load_mode == '4bit':
+            quantize_4bit(image_encoder)
+        
+        if fixed_vae:
+            vae = AutoencoderKL.from_pretrained(vae_model_id, torch_dtype=dtype)
+        else:            
+            vae = AutoencoderKL.from_pretrained(model_id,
+                                                subfolder="vae",
+                                                torch_dtype=dtype,
+            )
+
+        # "stabilityai/stable-diffusion-xl-base-1.0",
+        UNet_Encoder = UNet2DConditionModel_ref.from_pretrained(
+            model_id,
+            subfolder="unet_encoder",
+            torch_dtype=dtypeQuantize,
+        )
+     
+        if load_mode == '4bit':
+            quantize_4bit(UNet_Encoder)
+
+        UNet_Encoder.requires_grad_(False)
+        image_encoder.requires_grad_(False)
+        vae.requires_grad_(False)
+        unet.requires_grad_(False)
+              
+        pipe_param = {
+                'pretrained_model_name_or_path': model_id,
+                'unet': unet,     
+                'torch_dtype': dtype,   
+                'vae': vae,
+                'image_encoder': image_encoder,
+                'feature_extractor': CLIPImageProcessor(),
+            }
+        
+        pipe = TryonPipeline.from_pretrained(**pipe_param).to(device)
+        pipe.unet_encoder = UNet_Encoder    
+        pipe.unet_encoder.to(pipe.unet.device)
+
+        if load_mode == '4bit':
+            if pipe.text_encoder is not None:
+                quantize_4bit(pipe.text_encoder)
+            if pipe.text_encoder_2 is not None:
+                quantize_4bit(pipe.text_encoder_2)
+           
+    else:
+        if ENABLE_CPU_OFFLOAD:
+            need_restart_cpu_offloading =True
+    
+    torch_gc() 
+    parsing_model = Parsing(0)
+    openpose_model = OpenPose(0)
+    openpose_model.preprocessor.body_estimation.model.to(device)
+    tensor_transfrom = transforms.Compose(
+                    [
+                        transforms.ToTensor(),
+                        transforms.Normalize([0.5], [0.5]),
+                    ]
+            )
+    
+    if need_restart_cpu_offloading:
+        restart_cpu_offload(pipe, load_mode)
+    elif ENABLE_CPU_OFFLOAD:
+        pipe.enable_model_cpu_offload()
+
+    #if load_mode != '4bit' :
+    #    pipe.enable_xformers_memory_efficient_attention()    
+
+    garm_img= garm_img.convert("RGB").resize((768,1024))
+    human_img_orig = dict["background"].convert("RGB")    
+    
+    if is_checked_crop:
+        width, height = human_img_orig.size
+        target_width = int(min(width, height * (3 / 4)))
+        target_height = int(min(height, width * (4 / 3)))
+        left = (width - target_width) / 2
+        top = (height - target_height) / 2
+        right = (width + target_width) / 2
+        bottom = (height + target_height) / 2
+        cropped_img = human_img_orig.crop((left, top, right, bottom))
+        crop_size = cropped_img.size
+        human_img = cropped_img.resize((768,1024))
+    else:
+        human_img = human_img_orig.resize((768,1024))
+
+    if is_checked:
+        keypoints = openpose_model(human_img.resize((384,512)))
+        model_parse, _ = parsing_model(human_img.resize((384,512)))
+        mask, mask_gray = get_mask_location('hd', category, model_parse, keypoints)
+        mask = mask.resize((768,1024))
+    else:
+        mask = pil_to_binary_mask(dict['layers'][0].convert("RGB").resize((768, 1024)))
+        # mask = transforms.ToTensor()(mask)
+        # mask = mask.unsqueeze(0)
+    
+    mask_gray = (1-transforms.ToTensor()(mask)) * tensor_transfrom(human_img)
+    mask_gray = to_pil_image((mask_gray+1.0)/2.0)
+
+    human_img_arg = _apply_exif_orientation(human_img.resize((384,512)))
+    human_img_arg = convert_PIL_to_numpy(human_img_arg, format="BGR")
+
+    args = apply_net.create_argument_parser().parse_args(('show', './configs/densepose_rcnn_R_50_FPN_s1x.yaml', './ckpt/densepose/model_final_162be9.pkl', 'dp_segm', '-v', '--opts', 'MODEL.DEVICE', 'cuda'))
+    # verbosity = getattr(args, "verbosity", None)
+    pose_img = args.func(args,human_img_arg)    
+    pose_img = pose_img[:,:,::-1]    
+    pose_img = Image.fromarray(pose_img).resize((768,1024))
+    
+    if pipe.text_encoder is not None:        
+        pipe.text_encoder.to(device)
+
+    if pipe.text_encoder_2 is not None:
+        pipe.text_encoder_2.to(device)
+
+    with torch.no_grad():
+        # Extract the images
+        with torch.cuda.amp.autocast(dtype=dtype):
+            with torch.no_grad():
+                prompt = "model is wearing " + garment_des
+                negative_prompt = "monochrome, lowres, bad anatomy, worst quality, low quality"
+                with torch.inference_mode():
+                    (
+                        prompt_embeds,
+                        negative_prompt_embeds,
+                        pooled_prompt_embeds,
+                        negative_pooled_prompt_embeds,
+                    ) = pipe.encode_prompt(
+                        prompt,
+                        num_images_per_prompt=1,
+                        do_classifier_free_guidance=True,
+                        negative_prompt=negative_prompt,
+                    )
+                                    
+                    prompt = "a photo of " + garment_des
+                    negative_prompt = "monochrome, lowres, bad anatomy, worst quality, low quality"
+                    if not isinstance(prompt, List):
+                        prompt = [prompt] * 1
+                    if not isinstance(negative_prompt, List):
+                        negative_prompt = [negative_prompt] * 1
+                    with torch.inference_mode():
+                        (
+                            prompt_embeds_c,
+                            _,
+                            _,
+                            _,
+                        ) = pipe.encode_prompt(
+                            prompt,
+                            num_images_per_prompt=1,
+                            do_classifier_free_guidance=False,
+                            negative_prompt=negative_prompt,
+                        )
+
+                    pose_img =  tensor_transfrom(pose_img).unsqueeze(0).to(device,dtype)
+                    garm_tensor =  tensor_transfrom(garm_img).unsqueeze(0).to(device,dtype)
+                    results = []
+                    current_seed = seed
+                    for i in range(number_of_images):  
+                        if is_randomize_seed:
+                            current_seed = torch.randint(0, 2**32, size=(1,)).item()                        
+                        generator = torch.Generator(device).manual_seed(current_seed) if seed != -1 else None                     
+                        current_seed = current_seed + i
+
+                        images = pipe(
+                            prompt_embeds=prompt_embeds.to(device,dtype),
+                            negative_prompt_embeds=negative_prompt_embeds.to(device,dtype),
+                            pooled_prompt_embeds=pooled_prompt_embeds.to(device,dtype),
+                            negative_pooled_prompt_embeds=negative_pooled_prompt_embeds.to(device,dtype),
+                            num_inference_steps=denoise_steps,
+                            generator=generator,
+                            strength = 1.0,
+                            pose_img = pose_img.to(device,dtype),
+                            text_embeds_cloth=prompt_embeds_c.to(device,dtype),
+                            cloth = garm_tensor.to(device,dtype),
+                            mask_image=mask,
+                            image=human_img, 
+                            height=1024,
+                            width=768,
+                            ip_adapter_image = garm_img.resize((768,1024)),
+                            guidance_scale=2.0,
+                            dtype=dtype,
+                            device=device,
+                        )[0]
+                        if is_checked_crop:
+                            out_img = images[0].resize(crop_size)        
+                            human_img_orig.paste(out_img, (int(left), int(top)))   
+                            img_path = save_output_image(human_img_orig, base_path="outputs", base_filename='img', seed=current_seed)
+                            results.append(img_path)
+                        else:
+                            img_path = save_output_image(images[0], base_path="outputs", base_filename='img')
+                            results.append(img_path)
+                    return results, mask_gray
+    
+garm_list = os.listdir(os.path.join(example_path,"cloth"))
+garm_list_path = [os.path.join(example_path,"cloth",garm) for garm in garm_list]
+
+human_list = os.listdir(os.path.join(example_path,"human"))
+human_list_path = [os.path.join(example_path,"human",human) for human in human_list]
+
+human_ex_list = []
+for ex_human in human_list_path:
+    if "Jensen" in ex_human or "sam1 (1)" in ex_human:
+        ex_dict = {}
+        ex_dict['background'] = ex_human
+        ex_dict['layers'] = None
+        ex_dict['composite'] = None
+        human_ex_list.append(ex_dict)
+
+image_blocks = gr.Blocks().queue()
+with image_blocks as demo:
+    gr.Markdown("## V7 - IDM-VTON 👕👔👚 improved by SECourses and DEVAIEXP: 1-Click Installers Latest Version On : https://www.patreon.com/posts/103022942")
+    gr.Markdown("Virtual Try-on with your image and garment image. Check out the [source codes](https://github.com/yisol/IDM-VTON) and the [model](https://huggingface.co/yisol/IDM-VTON)")
+    with gr.Row():
+        with gr.Column():
+            imgs = gr.ImageEditor(sources='upload', type="pil", label='Human. Mask with pen or use auto-masking', interactive=True)
+            with gr.Row():
+                category = gr.Radio(choices=["upper_body", "lower_body", "dresses"], label="Select Garment Category", value="upper_body")
+                is_checked = gr.Checkbox(label="Yes", info="Use auto-generated mask (Takes 5 seconds)",value=True)
+            with gr.Row():
+                is_checked_crop = gr.Checkbox(label="Yes", info="Use auto-crop & resizing",value=True)
+
+            example = gr.Examples(
+                inputs=imgs,
+                examples_per_page=2,
+                examples=human_ex_list
+            )
+
+        with gr.Column():
+            garm_img = gr.Image(label="Garment", sources='upload', type="pil")
+            with gr.Row(elem_id="prompt-container"):
+                with gr.Row():
+                    prompt = gr.Textbox(placeholder="Description of garment ex) Short Sleeve Round Neck T-shirts", show_label=False, elem_id="prompt")
+            example = gr.Examples(
+                inputs=garm_img,
+                examples_per_page=8,
+                examples=garm_list_path)
+        with gr.Column():
+            with gr.Row():
+            # image_out = gr.Image(label="Output", elem_id="output-img", height=400)
+                masked_img = gr.Image(label="Masked image output", elem_id="masked-img",show_share_button=False)
+            with gr.Row():
+                btn_open_outputs = gr.Button("Open Outputs Folder")
+                btn_open_outputs.click(fn=open_folder)
+        with gr.Column():
+            with gr.Row():
+            # image_out = gr.Image(label="Output", elem_id="output-img", height=400)
+                image_gallery = gr.Gallery(label="Generated Images", show_label=True)
+            with gr.Row():
+                try_button = gr.Button(value="Try-on")
+                denoise_steps = gr.Number(label="Denoising Steps", minimum=20, maximum=120, value=30, step=1)
+                seed = gr.Number(label="Seed", minimum=-1, maximum=2147483647, step=1, value=1)
+                is_randomize_seed = gr.Checkbox(label="Randomize seed for each generated image", value=True)  
+                number_of_images = gr.Number(label="Number Of Images To Generate (it will start from your input seed and increment by 1)", minimum=1, maximum=9999, value=1, step=1)
+
+
+    try_button.click(fn=start_tryon, inputs=[imgs, garm_img, prompt, category, is_checked, is_checked_crop, denoise_steps, is_randomize_seed, seed, number_of_images], outputs=[image_gallery, masked_img],api_name='tryon')
+
+image_blocks.launch(inbrowser=True,share=args.share)

apply_net.py

@@ -0,0 +1,359 @@
+#!/usr/bin/env python3
+# Copyright (c) Facebook, Inc. and its affiliates.
+
+import argparse
+import glob
+import logging
+import os
+import sys
+from typing import Any, ClassVar, Dict, List
+import torch
+
+from detectron2.config import CfgNode, get_cfg
+from detectron2.data.detection_utils import read_image
+from detectron2.engine.defaults import DefaultPredictor
+from detectron2.structures.instances import Instances
+from detectron2.utils.logger import setup_logger
+
+from densepose import add_densepose_config
+from densepose.structures import DensePoseChartPredictorOutput, DensePoseEmbeddingPredictorOutput
+from densepose.utils.logger import verbosity_to_level
+from densepose.vis.base import CompoundVisualizer
+from densepose.vis.bounding_box import ScoredBoundingBoxVisualizer
+from densepose.vis.densepose_outputs_vertex import (
+    DensePoseOutputsTextureVisualizer,
+    DensePoseOutputsVertexVisualizer,
+    get_texture_atlases,
+)
+from densepose.vis.densepose_results import (
+    DensePoseResultsContourVisualizer,
+    DensePoseResultsFineSegmentationVisualizer,
+    DensePoseResultsUVisualizer,
+    DensePoseResultsVVisualizer,
+)
+from densepose.vis.densepose_results_textures import (
+    DensePoseResultsVisualizerWithTexture,
+    get_texture_atlas,
+)
+from densepose.vis.extractor import (
+    CompoundExtractor,
+    DensePoseOutputsExtractor,
+    DensePoseResultExtractor,
+    create_extractor,
+)
+
+DOC = """Apply Net - a tool to print / visualize DensePose results
+"""
+
+LOGGER_NAME = "apply_net"
+logger = logging.getLogger(LOGGER_NAME)
+
+_ACTION_REGISTRY: Dict[str, "Action"] = {}
+
+
+class Action:
+    @classmethod
+    def add_arguments(cls: type, parser: argparse.ArgumentParser):
+        parser.add_argument(
+            "-v",
+            "--verbosity",
+            action="count",
+            help="Verbose mode. Multiple -v options increase the verbosity.",
+        )
+
+
+def register_action(cls: type):
+    """
+    Decorator for action classes to automate action registration
+    """
+    global _ACTION_REGISTRY
+    _ACTION_REGISTRY[cls.COMMAND] = cls
+    return cls
+
+
+class InferenceAction(Action):
+    @classmethod
+    def add_arguments(cls: type, parser: argparse.ArgumentParser):
+        super(InferenceAction, cls).add_arguments(parser)
+        parser.add_argument("cfg", metavar="<config>", help="Config file")
+        parser.add_argument("model", metavar="<model>", help="Model file")
+        parser.add_argument(
+            "--opts",
+            help="Modify config options using the command-line 'KEY VALUE' pairs",
+            default=[],
+            nargs=argparse.REMAINDER,
+        )
+
+    @classmethod
+    def execute(cls: type, args: argparse.Namespace, human_img):
+        logger.info(f"Loading config from {args.cfg}")
+        opts = []
+        cfg = cls.setup_config(args.cfg, args.model, args, opts)
+        logger.info(f"Loading model from {args.model}")
+        predictor = DefaultPredictor(cfg)
+        # logger.info(f"Loading data from {args.input}")
+        # file_list = cls._get_input_file_list(args.input)
+        # if len(file_list) == 0:
+        #     logger.warning(f"No input images for {args.input}")
+        #     return
+        context = cls.create_context(args, cfg)
+        # for file_name in file_list:
+        #     img = read_image(file_name, format="BGR")  # predictor expects BGR image.
+        with torch.no_grad():
+            outputs = predictor(human_img)["instances"]
+            out_pose = cls.execute_on_outputs(context, {"image": human_img}, outputs)
+        cls.postexecute(context)
+        return out_pose
+
+    @classmethod
+    def setup_config(
+        cls: type, config_fpath: str, model_fpath: str, args: argparse.Namespace, opts: List[str]
+    ):
+        cfg = get_cfg()
+        add_densepose_config(cfg)
+        cfg.merge_from_file(config_fpath)
+        cfg.merge_from_list(args.opts)
+        if opts:
+            cfg.merge_from_list(opts)
+        cfg.MODEL.WEIGHTS = model_fpath
+        cfg.freeze()
+        return cfg
+
+    @classmethod
+    def _get_input_file_list(cls: type, input_spec: str):
+        if os.path.isdir(input_spec):
+            file_list = [
+                os.path.join(input_spec, fname)
+                for fname in os.listdir(input_spec)
+                if os.path.isfile(os.path.join(input_spec, fname))
+            ]
+        elif os.path.isfile(input_spec):
+            file_list = [input_spec]
+        else:
+            file_list = glob.glob(input_spec)
+        return file_list
+
+
+@register_action
+class DumpAction(InferenceAction):
+    """
+    Dump action that outputs results to a pickle file
+    """
+
+    COMMAND: ClassVar[str] = "dump"
+
+    @classmethod
+    def add_parser(cls: type, subparsers: argparse._SubParsersAction):
+        parser = subparsers.add_parser(cls.COMMAND, help="Dump model outputs to a file.")
+        cls.add_arguments(parser)
+        parser.set_defaults(func=cls.execute)
+
+    @classmethod
+    def add_arguments(cls: type, parser: argparse.ArgumentParser):
+        super(DumpAction, cls).add_arguments(parser)
+        parser.add_argument(
+            "--output",
+            metavar="<dump_file>",
+            default="results.pkl",
+            help="File name to save dump to",
+        )
+
+    @classmethod
+    def execute_on_outputs(
+        cls: type, context: Dict[str, Any], entry: Dict[str, Any], outputs: Instances
+    ):
+        image_fpath = entry["file_name"]
+        logger.info(f"Processing {image_fpath}")
+        result = {"file_name": image_fpath}
+        if outputs.has("scores"):
+            result["scores"] = outputs.get("scores").cpu()
+        if outputs.has("pred_boxes"):
+            result["pred_boxes_XYXY"] = outputs.get("pred_boxes").tensor.cpu()
+            if outputs.has("pred_densepose"):
+                if isinstance(outputs.pred_densepose, DensePoseChartPredictorOutput):
+                    extractor = DensePoseResultExtractor()
+                elif isinstance(outputs.pred_densepose, DensePoseEmbeddingPredictorOutput):
+                    extractor = DensePoseOutputsExtractor()
+                result["pred_densepose"] = extractor(outputs)[0]
+        context["results"].append(result)
+
+    @classmethod
+    def create_context(cls: type, args: argparse.Namespace, cfg: CfgNode):
+        context = {"results": [], "out_fname": args.output}
+        return context
+
+    @classmethod
+    def postexecute(cls: type, context: Dict[str, Any]):
+        out_fname = context["out_fname"]
+        out_dir = os.path.dirname(out_fname)
+        if len(out_dir) > 0 and not os.path.exists(out_dir):
+            os.makedirs(out_dir)
+        with open(out_fname, "wb") as hFile:
+            torch.save(context["results"], hFile)
+            logger.info(f"Output saved to {out_fname}")
+
+
+@register_action
+class ShowAction(InferenceAction):
+    """
+    Show action that visualizes selected entries on an image
+    """
+
+    COMMAND: ClassVar[str] = "show"
+    VISUALIZERS: ClassVar[Dict[str, object]] = {
+        "dp_contour": DensePoseResultsContourVisualizer,
+        "dp_segm": DensePoseResultsFineSegmentationVisualizer,
+        "dp_u": DensePoseResultsUVisualizer,
+        "dp_v": DensePoseResultsVVisualizer,
+        "dp_iuv_texture": DensePoseResultsVisualizerWithTexture,
+        "dp_cse_texture": DensePoseOutputsTextureVisualizer,
+        "dp_vertex": DensePoseOutputsVertexVisualizer,
+        "bbox": ScoredBoundingBoxVisualizer,
+    }
+
+    @classmethod
+    def add_parser(cls: type, subparsers: argparse._SubParsersAction):
+        parser = subparsers.add_parser(cls.COMMAND, help="Visualize selected entries")
+        cls.add_arguments(parser)
+        parser.set_defaults(func=cls.execute)
+
+    @classmethod
+    def add_arguments(cls: type, parser: argparse.ArgumentParser):
+        super(ShowAction, cls).add_arguments(parser)
+        parser.add_argument(
+            "visualizations",
+            metavar="<visualizations>",
+            help="Comma separated list of visualizations, possible values: "
+            "[{}]".format(",".join(sorted(cls.VISUALIZERS.keys()))),
+        )
+        parser.add_argument(
+            "--min_score",
+            metavar="<score>",
+            default=0.8,
+            type=float,
+            help="Minimum detection score to visualize",
+        )
+        parser.add_argument(
+            "--nms_thresh", metavar="<threshold>", default=None, type=float, help="NMS threshold"
+        )
+        parser.add_argument(
+            "--texture_atlas",
+            metavar="<texture_atlas>",
+            default=None,
+            help="Texture atlas file (for IUV texture transfer)",
+        )
+        parser.add_argument(
+            "--texture_atlases_map",
+            metavar="<texture_atlases_map>",
+            default=None,
+            help="JSON string of a dict containing texture atlas files for each mesh",
+        )
+        parser.add_argument(
+            "--output",
+            metavar="<image_file>",
+            default="outputres.png",
+            help="File name to save output to",
+        )
+
+    @classmethod
+    def setup_config(
+        cls: type, config_fpath: str, model_fpath: str, args: argparse.Namespace, opts: List[str]
+    ):
+        opts.append("MODEL.ROI_HEADS.SCORE_THRESH_TEST")
+        opts.append(str(args.min_score))
+        if args.nms_thresh is not None:
+            opts.append("MODEL.ROI_HEADS.NMS_THRESH_TEST")
+            opts.append(str(args.nms_thresh))
+        cfg = super(ShowAction, cls).setup_config(config_fpath, model_fpath, args, opts)
+        return cfg
+
+    @classmethod
+    def execute_on_outputs(
+        cls: type, context: Dict[str, Any], entry: Dict[str, Any], outputs: Instances
+    ):
+        import cv2
+        import numpy as np
+        visualizer = context["visualizer"]
+        extractor = context["extractor"]
+        # image_fpath = entry["file_name"]
+        # logger.info(f"Processing {image_fpath}")
+        image = cv2.cvtColor(entry["image"], cv2.COLOR_BGR2GRAY)
+        image = np.tile(image[:, :, np.newaxis], [1, 1, 3])
+        data = extractor(outputs)
+        image_vis = visualizer.visualize(image, data)
+
+        return image_vis
+        entry_idx = context["entry_idx"] + 1
+        out_fname = './image-densepose/' + image_fpath.split('/')[-1]
+        out_dir = './image-densepose'
+        out_dir = os.path.dirname(out_fname)
+        if len(out_dir) > 0 and not os.path.exists(out_dir):
+            os.makedirs(out_dir)
+        cv2.imwrite(out_fname, image_vis)
+        logger.info(f"Output saved to {out_fname}")
+        context["entry_idx"] += 1
+
+    @classmethod
+    def postexecute(cls: type, context: Dict[str, Any]):
+        pass
+# python ./apply_net.py show ./configs/densepose_rcnn_R_50_FPN_s1x.yaml https://dl.fbaipublicfiles.com/densepose/densepose_rcnn_R_50_FPN_s1x/165712039/model_final_162be9.pkl /home/alin0222/DressCode/upper_body/images dp_segm -v --opts MODEL.DEVICE cpu
+
+    @classmethod
+    def _get_out_fname(cls: type, entry_idx: int, fname_base: str):
+        base, ext = os.path.splitext(fname_base)
+        return base + ".{0:04d}".format(entry_idx) + ext
+
+    @classmethod
+    def create_context(cls: type, args: argparse.Namespace, cfg: CfgNode) -> Dict[str, Any]:
+        vis_specs = args.visualizations.split(",")
+        visualizers = []
+        extractors = []
+        for vis_spec in vis_specs:
+            texture_atlas = get_texture_atlas(args.texture_atlas)
+            texture_atlases_dict = get_texture_atlases(args.texture_atlases_map)
+            vis = cls.VISUALIZERS[vis_spec](
+                cfg=cfg,
+                texture_atlas=texture_atlas,
+                texture_atlases_dict=texture_atlases_dict,
+            )
+            visualizers.append(vis)
+            extractor = create_extractor(vis)
+            extractors.append(extractor)
+        visualizer = CompoundVisualizer(visualizers)
+        extractor = CompoundExtractor(extractors)
+        context = {
+            "extractor": extractor,
+            "visualizer": visualizer,
+            "out_fname": args.output,
+            "entry_idx": 0,
+        }
+        return context
+
+
+def create_argument_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description=DOC,
+        formatter_class=lambda prog: argparse.HelpFormatter(prog, max_help_position=120),
+    )
+    parser.set_defaults(func=lambda _: parser.print_help(sys.stdout))
+    subparsers = parser.add_subparsers(title="Actions")
+    for _, action in _ACTION_REGISTRY.items():
+        action.add_parser(subparsers)
+    return parser
+
+
+def main():
+    parser = create_argument_parser()
+    args = parser.parse_args()
+    verbosity = getattr(args, "verbosity", None)
+    global logger
+    logger = setup_logger(name=LOGGER_NAME)
+    logger.setLevel(verbosity_to_level(verbosity))
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()
+
+
+# python ./apply_net.py show ./configs/densepose_rcnn_R_50_FPN_s1x.yaml https://dl.fbaipublicfiles.com/densepose/densepose_rcnn_R_50_FPN_s1x/165712039/model_final_162be9.pkl /home/alin0222/Dresscode/dresses/humanonly dp_segm -v --opts MODEL.DEVICE cuda

ckpt/densepose/model_final_162be9.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b8a7382001b16e453bad95ca9dbc68ae8f2b839b304cf90eaf5c27fbdb4dae91
+size 255757821

ckpt/humanparsing/parsing_atr.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:04c7d1d070d0e0ae943d86b18cb5aaaea9e278d97462e9cfb270cbbe4cd977f4
+size 266859305

ckpt/humanparsing/parsing_lip.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8436e1dae96e2601c373d1ace29c8f0978b16357d9038c17a8ba756cca376dbc
+size 266863411

ckpt/openpose/.DS_Store

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e953475b1378e1d0566f8ad8de20077ce8610ae23fb2b5f8bfe57104aca8e911
+size 6148

ckpt/openpose/ckpts/body_pose_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:25a948c16078b0f08e236bda51a385d855ef4c153598947c28c0d47ed94bb746
+size 209267595

configs/Base-DensePose-RCNN-FPN.yaml

@@ -0,0 +1,48 @@
+VERSION: 2
+MODEL:
+  META_ARCHITECTURE: "GeneralizedRCNN"
+  BACKBONE:
+    NAME: "build_resnet_fpn_backbone"
+  RESNETS:
+    OUT_FEATURES: ["res2", "res3", "res4", "res5"]
+  FPN:
+    IN_FEATURES: ["res2", "res3", "res4", "res5"]
+  ANCHOR_GENERATOR:
+    SIZES: [[32], [64], [128], [256], [512]]  # One size for each in feature map
+    ASPECT_RATIOS: [[0.5, 1.0, 2.0]]  # Three aspect ratios (same for all in feature maps)
+  RPN:
+    IN_FEATURES: ["p2", "p3", "p4", "p5", "p6"]
+    PRE_NMS_TOPK_TRAIN: 2000  # Per FPN level
+    PRE_NMS_TOPK_TEST: 1000  # Per FPN level
+    # Detectron1 uses 2000 proposals per-batch,
+    # (See "modeling/rpn/rpn_outputs.py" for details of this legacy issue)
+    # which is approximately 1000 proposals per-image since the default batch size for FPN is 2.
+    POST_NMS_TOPK_TRAIN: 1000
+    POST_NMS_TOPK_TEST: 1000
+
+  DENSEPOSE_ON: True
+  ROI_HEADS:
+    NAME: "DensePoseROIHeads"
+    IN_FEATURES: ["p2", "p3", "p4", "p5"]
+    NUM_CLASSES: 1
+  ROI_BOX_HEAD:
+    NAME: "FastRCNNConvFCHead"
+    NUM_FC: 2
+    POOLER_RESOLUTION: 7
+    POOLER_SAMPLING_RATIO: 2
+    POOLER_TYPE: "ROIAlign"
+  ROI_DENSEPOSE_HEAD:
+    NAME: "DensePoseV1ConvXHead"
+    POOLER_TYPE: "ROIAlign"
+    NUM_COARSE_SEGM_CHANNELS: 2
+DATASETS:
+  TRAIN: ("densepose_coco_2014_train", "densepose_coco_2014_valminusminival")
+  TEST: ("densepose_coco_2014_minival",)
+SOLVER:
+  IMS_PER_BATCH: 16
+  BASE_LR: 0.01
+  STEPS: (60000, 80000)
+  MAX_ITER: 90000
+  WARMUP_FACTOR: 0.1
+INPUT:
+  MIN_SIZE_TRAIN: (640, 672, 704, 736, 768, 800)

configs/HRNet/densepose_rcnn_HRFPN_HRNet_w32_s1x.yaml

@@ -0,0 +1,16 @@
+_BASE_: "../Base-DensePose-RCNN-FPN.yaml"
+MODEL:
+  WEIGHTS: "https://1drv.ms/u/s!Aus8VCZ_C_33dYBMemi9xOUFR0w"
+  BACKBONE:
+    NAME: "build_hrfpn_backbone"
+  RPN:
+    IN_FEATURES: ['p1', 'p2', 'p3', 'p4', 'p5']
+  ROI_HEADS:
+    IN_FEATURES: ['p1', 'p2', 'p3', 'p4', 'p5']
+SOLVER:
+  MAX_ITER: 130000
+  STEPS: (100000, 120000)
+  CLIP_GRADIENTS:
+    ENABLED: True
+    CLIP_TYPE: "norm"
+  BASE_LR: 0.03

configs/HRNet/densepose_rcnn_HRFPN_HRNet_w40_s1x.yaml

@@ -0,0 +1,23 @@
+_BASE_: "../Base-DensePose-RCNN-FPN.yaml"
+MODEL:
+  WEIGHTS: "https://1drv.ms/u/s!Aus8VCZ_C_33ck0gvo5jfoWBOPo"
+  BACKBONE:
+    NAME: "build_hrfpn_backbone"
+  RPN:
+    IN_FEATURES: ['p1', 'p2', 'p3', 'p4', 'p5']
+  ROI_HEADS:
+    IN_FEATURES: ['p1', 'p2', 'p3', 'p4', 'p5']
+  HRNET:
+    STAGE2:
+      NUM_CHANNELS: [40, 80]
+    STAGE3:
+      NUM_CHANNELS: [40, 80, 160]
+    STAGE4:
+      NUM_CHANNELS: [40, 80, 160, 320]
+SOLVER:
+  MAX_ITER: 130000
+  STEPS: (100000, 120000)
+  CLIP_GRADIENTS:
+    ENABLED: True
+    CLIP_TYPE: "norm"
+  BASE_LR: 0.03

configs/HRNet/densepose_rcnn_HRFPN_HRNet_w48_s1x.yaml

@@ -0,0 +1,23 @@
+_BASE_: "../Base-DensePose-RCNN-FPN.yaml"
+MODEL:
+  WEIGHTS: "https://1drv.ms/u/s!Aus8VCZ_C_33dKvqI6pBZlifgJk"
+  BACKBONE:
+    NAME: "build_hrfpn_backbone"
+  RPN:
+    IN_FEATURES: ['p1', 'p2', 'p3', 'p4', 'p5']
+  ROI_HEADS:
+    IN_FEATURES: ['p1', 'p2', 'p3', 'p4', 'p5']
+  HRNET:
+    STAGE2:
+      NUM_CHANNELS: [48, 96]
+    STAGE3:
+      NUM_CHANNELS: [48, 96, 192]
+    STAGE4:
+      NUM_CHANNELS: [48, 96, 192, 384]
+SOLVER:
+  MAX_ITER: 130000
+  STEPS: (100000, 120000)
+  CLIP_GRADIENTS:
+    ENABLED: True
+    CLIP_TYPE: "norm"
+  BASE_LR: 0.03

configs/cse/Base-DensePose-RCNN-FPN-Human.yaml

@@ -0,0 +1,20 @@
+_BASE_: "Base-DensePose-RCNN-FPN.yaml"
+MODEL:
+  ROI_DENSEPOSE_HEAD:
+    CSE:
+      EMBEDDERS:
+        "smpl_27554":
+          TYPE: vertex_feature
+          NUM_VERTICES: 27554
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_smpl_27554_256.pkl"
+DATASETS:
+  TRAIN:
+    - "densepose_coco_2014_train_cse"
+    - "densepose_coco_2014_valminusminival_cse"
+  TEST:
+    - "densepose_coco_2014_minival_cse"
+  CLASS_TO_MESH_NAME_MAPPING:
+    "0": "smpl_27554"

configs/cse/Base-DensePose-RCNN-FPN.yaml

@@ -0,0 +1,60 @@
+VERSION: 2
+MODEL:
+  META_ARCHITECTURE: "GeneralizedRCNN"
+  BACKBONE:
+    NAME: "build_resnet_fpn_backbone"
+  RESNETS:
+    OUT_FEATURES: ["res2", "res3", "res4", "res5"]
+  FPN:
+    IN_FEATURES: ["res2", "res3", "res4", "res5"]
+  ANCHOR_GENERATOR:
+    SIZES: [[32], [64], [128], [256], [512]]  # One size for each in feature map
+    ASPECT_RATIOS: [[0.5, 1.0, 2.0]]  # Three aspect ratios (same for all in feature maps)
+  RPN:
+    IN_FEATURES: ["p2", "p3", "p4", "p5", "p6"]
+    PRE_NMS_TOPK_TRAIN: 2000  # Per FPN level
+    PRE_NMS_TOPK_TEST: 1000  # Per FPN level
+    # Detectron1 uses 2000 proposals per-batch,
+    # (See "modeling/rpn/rpn_outputs.py" for details of this legacy issue)
+    # which is approximately 1000 proposals per-image since the default batch size for FPN is 2.
+    POST_NMS_TOPK_TRAIN: 1000
+    POST_NMS_TOPK_TEST: 1000
+
+  DENSEPOSE_ON: True
+  ROI_HEADS:
+    NAME: "DensePoseROIHeads"
+    IN_FEATURES: ["p2", "p3", "p4", "p5"]
+    NUM_CLASSES: 1
+  ROI_BOX_HEAD:
+    NAME: "FastRCNNConvFCHead"
+    NUM_FC: 2
+    POOLER_RESOLUTION: 7
+    POOLER_SAMPLING_RATIO: 2
+    POOLER_TYPE: "ROIAlign"
+  ROI_DENSEPOSE_HEAD:
+    NAME: "DensePoseV1ConvXHead"
+    POOLER_TYPE: "ROIAlign"
+    NUM_COARSE_SEGM_CHANNELS: 2
+    PREDICTOR_NAME: "DensePoseEmbeddingPredictor"
+    LOSS_NAME: "DensePoseCseLoss"
+    CSE:
+      # embedding loss, possible values:
+      # - "EmbeddingLoss"
+      # - "SoftEmbeddingLoss"
+      EMBED_LOSS_NAME: "EmbeddingLoss"
+SOLVER:
+  IMS_PER_BATCH: 16
+  BASE_LR: 0.01
+  STEPS: (60000, 80000)
+  MAX_ITER: 90000
+  WARMUP_FACTOR: 0.1
+  CLIP_GRADIENTS:
+    CLIP_TYPE: norm
+    CLIP_VALUE: 1.0
+    ENABLED: true
+    NORM_TYPE: 2.0
+INPUT:
+  MIN_SIZE_TRAIN: (640, 672, 704, 736, 768, 800)
+DENSEPOSE_EVALUATION:
+  TYPE: cse
+  STORAGE: file

configs/cse/densepose_rcnn_R_101_FPN_DL_s1x.yaml

@@ -0,0 +1,12 @@
+_BASE_: "Base-DensePose-RCNN-FPN-Human.yaml"
+MODEL:
+  WEIGHTS: "detectron2://ImageNetPretrained/MSRA/R-101.pkl"
+  RESNETS:
+    DEPTH: 101
+  ROI_DENSEPOSE_HEAD:
+    NAME: "DensePoseDeepLabHead"
+    CSE:
+      EMBED_LOSS_NAME: "EmbeddingLoss"
+SOLVER:
+  MAX_ITER: 130000
+  STEPS: (100000, 120000)

configs/cse/densepose_rcnn_R_101_FPN_DL_soft_s1x.yaml

@@ -0,0 +1,12 @@
+_BASE_: "Base-DensePose-RCNN-FPN-Human.yaml"
+MODEL:
+  WEIGHTS: "detectron2://ImageNetPretrained/MSRA/R-101.pkl"
+  RESNETS:
+    DEPTH: 101
+  ROI_DENSEPOSE_HEAD:
+    NAME: "DensePoseDeepLabHead"
+    CSE:
+      EMBED_LOSS_NAME: "SoftEmbeddingLoss"
+SOLVER:
+  MAX_ITER: 130000
+  STEPS: (100000, 120000)

configs/cse/densepose_rcnn_R_101_FPN_s1x.yaml

@@ -0,0 +1,12 @@
+_BASE_: "Base-DensePose-RCNN-FPN-Human.yaml"
+MODEL:
+  WEIGHTS: "detectron2://ImageNetPretrained/MSRA/R-101.pkl"
+  RESNETS:
+    DEPTH: 101
+  ROI_DENSEPOSE_HEAD:
+    NAME: "DensePoseV1ConvXHead"
+    CSE:
+      EMBED_LOSS_NAME: "EmbeddingLoss"
+SOLVER:
+  MAX_ITER: 130000
+  STEPS: (100000, 120000)

configs/cse/densepose_rcnn_R_101_FPN_soft_s1x.yaml

@@ -0,0 +1,12 @@
+_BASE_: "Base-DensePose-RCNN-FPN-Human.yaml"
+MODEL:
+  WEIGHTS: "detectron2://ImageNetPretrained/MSRA/R-101.pkl"
+  RESNETS:
+    DEPTH: 101
+  ROI_DENSEPOSE_HEAD:
+    NAME: "DensePoseV1ConvXHead"
+    CSE:
+      EMBED_LOSS_NAME: "SoftEmbeddingLoss"
+SOLVER:
+  MAX_ITER: 130000
+  STEPS: (100000, 120000)

configs/cse/densepose_rcnn_R_50_FPN_DL_s1x.yaml

@@ -0,0 +1,12 @@
+_BASE_: "Base-DensePose-RCNN-FPN-Human.yaml"
+MODEL:
+  WEIGHTS: "detectron2://ImageNetPretrained/MSRA/R-50.pkl"
+  RESNETS:
+    DEPTH: 50
+  ROI_DENSEPOSE_HEAD:
+    NAME: "DensePoseDeepLabHead"
+    CSE:
+      EMBED_LOSS_NAME: "EmbeddingLoss"
+SOLVER:
+  MAX_ITER: 130000
+  STEPS: (100000, 120000)

configs/cse/densepose_rcnn_R_50_FPN_DL_soft_s1x.yaml

@@ -0,0 +1,12 @@
+_BASE_: "Base-DensePose-RCNN-FPN-Human.yaml"
+MODEL:
+  WEIGHTS: "detectron2://ImageNetPretrained/MSRA/R-50.pkl"
+  RESNETS:
+    DEPTH: 50
+  ROI_DENSEPOSE_HEAD:
+    NAME: "DensePoseDeepLabHead"
+    CSE:
+      EMBED_LOSS_NAME: "SoftEmbeddingLoss"
+SOLVER:
+  MAX_ITER: 130000
+  STEPS: (100000, 120000)

configs/cse/densepose_rcnn_R_50_FPN_s1x.yaml

@@ -0,0 +1,12 @@
+_BASE_: "Base-DensePose-RCNN-FPN-Human.yaml"
+MODEL:
+  WEIGHTS: "detectron2://ImageNetPretrained/MSRA/R-50.pkl"
+  RESNETS:
+    DEPTH: 50
+  ROI_DENSEPOSE_HEAD:
+    NAME: "DensePoseV1ConvXHead"
+    CSE:
+      EMBED_LOSS_NAME: "EmbeddingLoss"
+SOLVER:
+  MAX_ITER: 130000
+  STEPS: (100000, 120000)

configs/cse/densepose_rcnn_R_50_FPN_soft_animals_CA_finetune_16k.yaml

@@ -0,0 +1,133 @@
+_BASE_: "Base-DensePose-RCNN-FPN.yaml"
+MODEL:
+  WEIGHTS: "https://dl.fbaipublicfiles.com/densepose/cse/densepose_rcnn_R_50_FPN_soft_s1x/250533982/model_final_2c4512.pkl"
+  RESNETS:
+    DEPTH: 50
+  ROI_HEADS:
+    NUM_CLASSES: 1
+  ROI_DENSEPOSE_HEAD:
+    NAME: "DensePoseV1ConvXHead"
+    COARSE_SEGM_TRAINED_BY_MASKS: True
+    CSE:
+      EMBED_LOSS_NAME: "SoftEmbeddingLoss"
+      EMBEDDING_DIST_GAUSS_SIGMA: 0.1
+      GEODESIC_DIST_GAUSS_SIGMA: 0.1
+      EMBEDDERS:
+        "cat_7466":
+          TYPE: vertex_feature
+          NUM_VERTICES: 7466
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_cat_7466_256.pkl"
+        "dog_7466":
+          TYPE: vertex_feature
+          NUM_VERTICES: 7466
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_dog_7466_256.pkl"
+        "sheep_5004":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5004
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_sheep_5004_256.pkl"
+        "horse_5004":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5004
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_horse_5004_256.pkl"
+        "zebra_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_zebra_5002_256.pkl"
+        "giraffe_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_giraffe_5002_256.pkl"
+        "elephant_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_elephant_5002_256.pkl"
+        "cow_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_cow_5002_256.pkl"
+        "bear_4936":
+          TYPE: vertex_feature
+          NUM_VERTICES: 4936
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_bear_4936_256.pkl"
+DATASETS:
+  TRAIN:
+    - "densepose_lvis_v1_ds2_train_v1"
+  TEST:
+    - "densepose_lvis_v1_ds2_val_v1"
+  WHITELISTED_CATEGORIES:
+    "densepose_lvis_v1_ds2_train_v1":
+      - 943  # sheep
+      - 1202 # zebra
+      - 569  # horse
+      - 496  # giraffe
+      - 422  # elephant
+      - 80   # cow
+      - 76   # bear
+      - 225  # cat
+      - 378  # dog
+    "densepose_lvis_v1_ds2_val_v1":
+      - 943  # sheep
+      - 1202 # zebra
+      - 569  # horse
+      - 496  # giraffe
+      - 422  # elephant
+      - 80   # cow
+      - 76   # bear
+      - 225  # cat
+      - 378  # dog
+  CATEGORY_MAPS:
+    "densepose_lvis_v1_ds2_train_v1":
+      "1202": 943 # zebra -> sheep
+      "569": 943  # horse -> sheep
+      "496": 943  # giraffe -> sheep
+      "422": 943  # elephant -> sheep
+      "80": 943   # cow -> sheep
+      "76": 943   # bear -> sheep
+      "225": 943  # cat -> sheep
+      "378": 943  # dog -> sheep
+    "densepose_lvis_v1_ds2_val_v1":
+      "1202": 943 # zebra -> sheep
+      "569": 943  # horse -> sheep
+      "496": 943  # giraffe -> sheep
+      "422": 943  # elephant -> sheep
+      "80": 943   # cow -> sheep
+      "76": 943   # bear -> sheep
+      "225": 943  # cat -> sheep
+      "378": 943  # dog -> sheep
+  CLASS_TO_MESH_NAME_MAPPING:
+    # Note: different classes are mapped to a single class
+    # mesh is chosen based on GT data, so this is just some
+    # value which has no particular meaning
+    "0": "sheep_5004"
+SOLVER:
+  MAX_ITER: 16000
+  STEPS: (12000, 14000)
+DENSEPOSE_EVALUATION:
+  EVALUATE_MESH_ALIGNMENT: True

configs/cse/densepose_rcnn_R_50_FPN_soft_animals_CA_finetune_4k.yaml

@@ -0,0 +1,133 @@
+_BASE_: "Base-DensePose-RCNN-FPN.yaml"
+MODEL:
+  WEIGHTS: "https://dl.fbaipublicfiles.com/densepose/cse/densepose_rcnn_R_50_FPN_soft_s1x/250533982/model_final_2c4512.pkl"
+  RESNETS:
+    DEPTH: 50
+  ROI_HEADS:
+    NUM_CLASSES: 1
+  ROI_DENSEPOSE_HEAD:
+    NAME: "DensePoseV1ConvXHead"
+    COARSE_SEGM_TRAINED_BY_MASKS: True
+    CSE:
+      EMBED_LOSS_NAME: "SoftEmbeddingLoss"
+      EMBEDDING_DIST_GAUSS_SIGMA: 0.1
+      GEODESIC_DIST_GAUSS_SIGMA: 0.1
+      EMBEDDERS:
+        "cat_5001":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5001
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_cat_5001_256.pkl"
+        "dog_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_dog_5002_256.pkl"
+        "sheep_5004":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5004
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_sheep_5004_256.pkl"
+        "horse_5004":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5004
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_horse_5004_256.pkl"
+        "zebra_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_zebra_5002_256.pkl"
+        "giraffe_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_giraffe_5002_256.pkl"
+        "elephant_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_elephant_5002_256.pkl"
+        "cow_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_cow_5002_256.pkl"
+        "bear_4936":
+          TYPE: vertex_feature
+          NUM_VERTICES: 4936
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_bear_4936_256.pkl"
+DATASETS:
+  TRAIN:
+    - "densepose_lvis_v1_ds1_train_v1"
+  TEST:
+    - "densepose_lvis_v1_ds1_val_v1"
+  WHITELISTED_CATEGORIES:
+    "densepose_lvis_v1_ds1_train_v1":
+      - 943  # sheep
+      - 1202 # zebra
+      - 569  # horse
+      - 496  # giraffe
+      - 422  # elephant
+      - 80   # cow
+      - 76   # bear
+      - 225  # cat
+      - 378  # dog
+    "densepose_lvis_v1_ds1_val_v1":
+      - 943  # sheep
+      - 1202 # zebra
+      - 569  # horse
+      - 496  # giraffe
+      - 422  # elephant
+      - 80   # cow
+      - 76   # bear
+      - 225  # cat
+      - 378  # dog
+  CATEGORY_MAPS:
+    "densepose_lvis_v1_ds1_train_v1":
+      "1202": 943 # zebra -> sheep
+      "569": 943  # horse -> sheep
+      "496": 943  # giraffe -> sheep
+      "422": 943  # elephant -> sheep
+      "80": 943   # cow -> sheep
+      "76": 943   # bear -> sheep
+      "225": 943  # cat -> sheep
+      "378": 943  # dog -> sheep
+    "densepose_lvis_v1_ds1_val_v1":
+      "1202": 943 # zebra -> sheep
+      "569": 943  # horse -> sheep
+      "496": 943  # giraffe -> sheep
+      "422": 943  # elephant -> sheep
+      "80": 943   # cow -> sheep
+      "76": 943   # bear -> sheep
+      "225": 943  # cat -> sheep
+      "378": 943  # dog -> sheep
+  CLASS_TO_MESH_NAME_MAPPING:
+    # Note: different classes are mapped to a single class
+    # mesh is chosen based on GT data, so this is just some
+    # value which has no particular meaning
+    "0": "sheep_5004"
+SOLVER:
+  MAX_ITER: 4000
+  STEPS: (3000, 3500)
+DENSEPOSE_EVALUATION:
+  EVALUATE_MESH_ALIGNMENT: True

configs/cse/densepose_rcnn_R_50_FPN_soft_animals_I0_finetune_16k.yaml

@@ -0,0 +1,119 @@
+_BASE_: "Base-DensePose-RCNN-FPN.yaml"
+MODEL:
+  WEIGHTS: "https://dl.fbaipublicfiles.com/densepose/cse/densepose_rcnn_R_50_FPN_soft_animals_finetune_maskonly_24k/270668502/model_final_21b1d2.pkl"
+  RESNETS:
+    DEPTH: 50
+  ROI_HEADS:
+    NUM_CLASSES: 9
+  ROI_DENSEPOSE_HEAD:
+    NAME: "DensePoseV1ConvXHead"
+    COARSE_SEGM_TRAINED_BY_MASKS: True
+    CSE:
+      EMBED_LOSS_NAME: "SoftEmbeddingLoss"
+      EMBEDDING_DIST_GAUSS_SIGMA: 0.1
+      GEODESIC_DIST_GAUSS_SIGMA: 0.1
+      EMBEDDERS:
+        "cat_7466":
+          TYPE: vertex_feature
+          NUM_VERTICES: 7466
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_cat_7466_256.pkl"
+        "dog_7466":
+          TYPE: vertex_feature
+          NUM_VERTICES: 7466
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_dog_7466_256.pkl"
+        "sheep_5004":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5004
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_sheep_5004_256.pkl"
+        "horse_5004":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5004
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_horse_5004_256.pkl"
+        "zebra_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_zebra_5002_256.pkl"
+        "giraffe_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_giraffe_5002_256.pkl"
+        "elephant_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_elephant_5002_256.pkl"
+        "cow_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_cow_5002_256.pkl"
+        "bear_4936":
+          TYPE: vertex_feature
+          NUM_VERTICES: 4936
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_bear_4936_256.pkl"
+DATASETS:
+  TRAIN:
+    - "densepose_lvis_v1_ds2_train_v1"
+  TEST:
+    - "densepose_lvis_v1_ds2_val_v1"
+  WHITELISTED_CATEGORIES:
+    "densepose_lvis_v1_ds2_train_v1":
+      - 943  # sheep
+      - 1202 # zebra
+      - 569  # horse
+      - 496  # giraffe
+      - 422  # elephant
+      - 80   # cow
+      - 76   # bear
+      - 225  # cat
+      - 378  # dog
+    "densepose_lvis_v1_ds2_val_v1":
+      - 943  # sheep
+      - 1202 # zebra
+      - 569  # horse
+      - 496  # giraffe
+      - 422  # elephant
+      - 80   # cow
+      - 76   # bear
+      - 225  # cat
+      - 378  # dog
+  CLASS_TO_MESH_NAME_MAPPING:
+    "0": "bear_4936"
+    "1": "cow_5002"
+    "2": "cat_7466"
+    "3": "dog_7466"
+    "4": "elephant_5002"
+    "5": "giraffe_5002"
+    "6": "horse_5004"
+    "7": "sheep_5004"
+    "8": "zebra_5002"
+SOLVER:
+  MAX_ITER: 16000
+  STEPS: (12000, 14000)
+DENSEPOSE_EVALUATION:
+  EVALUATE_MESH_ALIGNMENT: True

configs/cse/densepose_rcnn_R_50_FPN_soft_animals_I0_finetune_i2m_16k.yaml

@@ -0,0 +1,121 @@
+_BASE_: "Base-DensePose-RCNN-FPN.yaml"
+MODEL:
+  WEIGHTS: "https://dl.fbaipublicfiles.com/densepose/cse/densepose_rcnn_R_50_FPN_soft_animals_finetune_maskonly_24k/270668502/model_final_21b1d2.pkl"
+  RESNETS:
+    DEPTH: 50
+  ROI_HEADS:
+    NUM_CLASSES: 9
+  ROI_DENSEPOSE_HEAD:
+    NAME: "DensePoseV1ConvXHead"
+    COARSE_SEGM_TRAINED_BY_MASKS: True
+    CSE:
+      EMBED_LOSS_NAME: "SoftEmbeddingLoss"
+      EMBEDDING_DIST_GAUSS_SIGMA: 0.1
+      GEODESIC_DIST_GAUSS_SIGMA: 0.1
+      PIX_TO_SHAPE_CYCLE_LOSS:
+        ENABLED: True
+      EMBEDDERS:
+        "cat_7466":
+          TYPE: vertex_feature
+          NUM_VERTICES: 7466
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_cat_7466_256.pkl"
+        "dog_7466":
+          TYPE: vertex_feature
+          NUM_VERTICES: 7466
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_dog_7466_256.pkl"
+        "sheep_5004":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5004
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_sheep_5004_256.pkl"
+        "horse_5004":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5004
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_horse_5004_256.pkl"
+        "zebra_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_zebra_5002_256.pkl"
+        "giraffe_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_giraffe_5002_256.pkl"
+        "elephant_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_elephant_5002_256.pkl"
+        "cow_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_cow_5002_256.pkl"
+        "bear_4936":
+          TYPE: vertex_feature
+          NUM_VERTICES: 4936
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_bear_4936_256.pkl"
+DATASETS:
+  TRAIN:
+    - "densepose_lvis_v1_ds2_train_v1"
+  TEST:
+    - "densepose_lvis_v1_ds2_val_v1"
+  WHITELISTED_CATEGORIES:
+    "densepose_lvis_v1_ds2_train_v1":
+      - 943  # sheep
+      - 1202 # zebra
+      - 569  # horse
+      - 496  # giraffe
+      - 422  # elephant
+      - 80   # cow
+      - 76   # bear
+      - 225  # cat
+      - 378  # dog
+    "densepose_lvis_v1_ds2_val_v1":
+      - 943  # sheep
+      - 1202 # zebra
+      - 569  # horse
+      - 496  # giraffe
+      - 422  # elephant
+      - 80   # cow
+      - 76   # bear
+      - 225  # cat
+      - 378  # dog
+  CLASS_TO_MESH_NAME_MAPPING:
+    "0": "bear_4936"
+    "1": "cow_5002"
+    "2": "cat_7466"
+    "3": "dog_7466"
+    "4": "elephant_5002"
+    "5": "giraffe_5002"
+    "6": "horse_5004"
+    "7": "sheep_5004"
+    "8": "zebra_5002"
+SOLVER:
+  MAX_ITER: 16000
+  STEPS: (12000, 14000)
+DENSEPOSE_EVALUATION:
+  EVALUATE_MESH_ALIGNMENT: True

configs/cse/densepose_rcnn_R_50_FPN_soft_animals_I0_finetune_m2m_16k.yaml

@@ -0,0 +1,138 @@
+_BASE_: "Base-DensePose-RCNN-FPN.yaml"
+MODEL:
+  WEIGHTS: "https://dl.fbaipublicfiles.com/densepose/cse/densepose_rcnn_R_50_FPN_soft_animals_finetune_maskonly_24k/267687159/model_final_354e61.pkl"
+  RESNETS:
+    DEPTH: 50
+  ROI_HEADS:
+    NUM_CLASSES: 9
+  ROI_DENSEPOSE_HEAD:
+    NAME: "DensePoseV1ConvXHead"
+    COARSE_SEGM_TRAINED_BY_MASKS: True
+    CSE:
+      EMBED_LOSS_NAME: "SoftEmbeddingLoss"
+      EMBEDDING_DIST_GAUSS_SIGMA: 0.1
+      GEODESIC_DIST_GAUSS_SIGMA: 0.1
+      SHAPE_TO_SHAPE_CYCLE_LOSS:
+        ENABLED: True
+      EMBEDDERS:
+        "cat_7466":
+          TYPE: vertex_feature
+          NUM_VERTICES: 7466
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_cat_7466_256.pkl"
+        "dog_7466":
+          TYPE: vertex_feature
+          NUM_VERTICES: 7466
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_dog_7466_256.pkl"
+        "sheep_5004":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5004
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_sheep_5004_256.pkl"
+        "horse_5004":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5004
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_horse_5004_256.pkl"
+        "zebra_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_zebra_5002_256.pkl"
+        "giraffe_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_giraffe_5002_256.pkl"
+        "elephant_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_elephant_5002_256.pkl"
+        "cow_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_cow_5002_256.pkl"
+        "bear_4936":
+          TYPE: vertex_feature
+          NUM_VERTICES: 4936
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_bear_4936_256.pkl"
+        "smpl_27554":
+          TYPE: vertex_feature
+          NUM_VERTICES: 27554
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_smpl_27554_256.pkl"
+DATASETS:
+  TRAIN:
+    - "densepose_lvis_v1_ds2_train_v1"
+  TEST:
+    - "densepose_lvis_v1_ds2_val_v1"
+  WHITELISTED_CATEGORIES:
+    "densepose_lvis_v1_ds2_train_v1":
+      - 943  # sheep
+      - 1202 # zebra
+      - 569  # horse
+      - 496  # giraffe
+      - 422  # elephant
+      - 80   # cow
+      - 76   # bear
+      - 225  # cat
+      - 378  # dog
+    "densepose_lvis_v1_ds2_val_v1":
+      - 943  # sheep
+      - 1202 # zebra
+      - 569  # horse
+      - 496  # giraffe
+      - 422  # elephant
+      - 80   # cow
+      - 76   # bear
+      - 225  # cat
+      - 378  # dog
+  CLASS_TO_MESH_NAME_MAPPING:
+    "0": "bear_4936"
+    "1": "cow_5002"
+    "2": "cat_7466"
+    "3": "dog_7466"
+    "4": "elephant_5002"
+    "5": "giraffe_5002"
+    "6": "horse_5004"
+    "7": "sheep_5004"
+    "8": "zebra_5002"
+SOLVER:
+  MAX_ITER: 16000
+  STEPS: (12000, 14000)
+DENSEPOSE_EVALUATION:
+  EVALUATE_MESH_ALIGNMENT: True
+  MESH_ALIGNMENT_MESH_NAMES:
+    - bear_4936
+    - cow_5002
+    - cat_7466
+    - dog_7466
+    - elephant_5002
+    - giraffe_5002
+    - horse_5004
+    - sheep_5004
+    - zebra_5002

configs/cse/densepose_rcnn_R_50_FPN_soft_animals_finetune_16k.yaml

@@ -0,0 +1,119 @@
+_BASE_: "Base-DensePose-RCNN-FPN.yaml"
+MODEL:
+  WEIGHTS: "https://dl.fbaipublicfiles.com/densepose/cse/densepose_rcnn_R_50_FPN_soft_s1x/250533982/model_final_2c4512.pkl"
+  RESNETS:
+    DEPTH: 50
+  ROI_HEADS:
+    NUM_CLASSES: 9
+  ROI_DENSEPOSE_HEAD:
+    NAME: "DensePoseV1ConvXHead"
+    COARSE_SEGM_TRAINED_BY_MASKS: True
+    CSE:
+      EMBED_LOSS_NAME: "SoftEmbeddingLoss"
+      EMBEDDING_DIST_GAUSS_SIGMA: 0.1
+      GEODESIC_DIST_GAUSS_SIGMA: 0.1
+      EMBEDDERS:
+        "cat_7466":
+          TYPE: vertex_feature
+          NUM_VERTICES: 7466
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_cat_7466_256.pkl"
+        "dog_7466":
+          TYPE: vertex_feature
+          NUM_VERTICES: 7466
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_dog_7466_256.pkl"
+        "sheep_5004":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5004
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_sheep_5004_256.pkl"
+        "horse_5004":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5004
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_horse_5004_256.pkl"
+        "zebra_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_zebra_5002_256.pkl"
+        "giraffe_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_giraffe_5002_256.pkl"
+        "elephant_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_elephant_5002_256.pkl"
+        "cow_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_cow_5002_256.pkl"
+        "bear_4936":
+          TYPE: vertex_feature
+          NUM_VERTICES: 4936
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_bear_4936_256.pkl"
+DATASETS:
+  TRAIN:
+    - "densepose_lvis_v1_ds2_train_v1"
+  TEST:
+    - "densepose_lvis_v1_ds2_val_v1"
+  WHITELISTED_CATEGORIES:
+    "densepose_lvis_v1_ds2_train_v1":
+      - 943  # sheep
+      - 1202 # zebra
+      - 569  # horse
+      - 496  # giraffe
+      - 422  # elephant
+      - 80   # cow
+      - 76   # bear
+      - 225  # cat
+      - 378  # dog
+    "densepose_lvis_v1_ds2_val_v1":
+      - 943  # sheep
+      - 1202 # zebra
+      - 569  # horse
+      - 496  # giraffe
+      - 422  # elephant
+      - 80   # cow
+      - 76   # bear
+      - 225  # cat
+      - 378  # dog
+  CLASS_TO_MESH_NAME_MAPPING:
+    "0": "bear_4936"
+    "1": "cow_5002"
+    "2": "cat_7466"
+    "3": "dog_7466"
+    "4": "elephant_5002"
+    "5": "giraffe_5002"
+    "6": "horse_5004"
+    "7": "sheep_5004"
+    "8": "zebra_5002"
+SOLVER:
+  MAX_ITER: 16000
+  STEPS: (12000, 14000)
+DENSEPOSE_EVALUATION:
+  EVALUATE_MESH_ALIGNMENT: True

configs/cse/densepose_rcnn_R_50_FPN_soft_animals_finetune_4k.yaml

@@ -0,0 +1,119 @@
+_BASE_: "Base-DensePose-RCNN-FPN.yaml"
+MODEL:
+  WEIGHTS: "https://dl.fbaipublicfiles.com/densepose/cse/densepose_rcnn_R_50_FPN_soft_s1x/250533982/model_final_2c4512.pkl"
+  RESNETS:
+    DEPTH: 50
+  ROI_HEADS:
+    NUM_CLASSES: 9
+  ROI_DENSEPOSE_HEAD:
+    NAME: "DensePoseV1ConvXHead"
+    COARSE_SEGM_TRAINED_BY_MASKS: True
+    CSE:
+      EMBED_LOSS_NAME: "SoftEmbeddingLoss"
+      EMBEDDING_DIST_GAUSS_SIGMA: 0.1
+      GEODESIC_DIST_GAUSS_SIGMA: 0.1
+      EMBEDDERS:
+        "cat_5001":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5001
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_cat_5001_256.pkl"
+        "dog_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_dog_5002_256.pkl"
+        "sheep_5004":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5004
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_sheep_5004_256.pkl"
+        "horse_5004":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5004
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_horse_5004_256.pkl"
+        "zebra_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_zebra_5002_256.pkl"
+        "giraffe_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_giraffe_5002_256.pkl"
+        "elephant_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_elephant_5002_256.pkl"
+        "cow_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_cow_5002_256.pkl"
+        "bear_4936":
+          TYPE: vertex_feature
+          NUM_VERTICES: 4936
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_bear_4936_256.pkl"
+DATASETS:
+  TRAIN:
+    - "densepose_lvis_v1_ds1_train_v1"
+  TEST:
+    - "densepose_lvis_v1_ds1_val_v1"
+  WHITELISTED_CATEGORIES:
+    "densepose_lvis_v1_ds1_train_v1":
+      - 943  # sheep
+      - 1202 # zebra
+      - 569  # horse
+      - 496  # giraffe
+      - 422  # elephant
+      - 80   # cow
+      - 76   # bear
+      - 225  # cat
+      - 378  # dog
+    "densepose_lvis_v1_ds1_val_v1":
+      - 943  # sheep
+      - 1202 # zebra
+      - 569  # horse
+      - 496  # giraffe
+      - 422  # elephant
+      - 80   # cow
+      - 76   # bear
+      - 225  # cat
+      - 378  # dog
+  CLASS_TO_MESH_NAME_MAPPING:
+    "0": "bear_4936"
+    "1": "cow_5002"
+    "2": "cat_5001"
+    "3": "dog_5002"
+    "4": "elephant_5002"
+    "5": "giraffe_5002"
+    "6": "horse_5004"
+    "7": "sheep_5004"
+    "8": "zebra_5002"
+SOLVER:
+  MAX_ITER: 4000
+  STEPS: (3000, 3500)
+DENSEPOSE_EVALUATION:
+  EVALUATE_MESH_ALIGNMENT: True

configs/cse/densepose_rcnn_R_50_FPN_soft_animals_finetune_maskonly_24k.yaml

@@ -0,0 +1,118 @@
+_BASE_: "Base-DensePose-RCNN-FPN.yaml"
+MODEL:
+  WEIGHTS: "https://dl.fbaipublicfiles.com/densepose/cse/densepose_rcnn_R_50_FPN_soft_s1x/250533982/model_final_2c4512.pkl"
+  RESNETS:
+    DEPTH: 50
+  ROI_HEADS:
+    NUM_CLASSES: 9
+  ROI_DENSEPOSE_HEAD:
+    NAME: "DensePoseV1ConvXHead"
+    COARSE_SEGM_TRAINED_BY_MASKS: True
+    CSE:
+      EMBED_LOSS_NAME: "SoftEmbeddingLoss"
+      EMBED_LOSS_WEIGHT: 0.0
+      EMBEDDING_DIST_GAUSS_SIGMA: 0.1
+      GEODESIC_DIST_GAUSS_SIGMA: 0.1
+      EMBEDDERS:
+        "cat_7466":
+          TYPE: vertex_feature
+          NUM_VERTICES: 7466
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_cat_7466_256.pkl"
+        "dog_7466":
+          TYPE: vertex_feature
+          NUM_VERTICES: 7466
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_dog_7466_256.pkl"
+        "sheep_5004":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5004
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_sheep_5004_256.pkl"
+        "horse_5004":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5004
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_horse_5004_256.pkl"
+        "zebra_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_zebra_5002_256.pkl"
+        "giraffe_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_giraffe_5002_256.pkl"
+        "elephant_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_elephant_5002_256.pkl"
+        "cow_5002":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5002
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_cow_5002_256.pkl"
+        "bear_4936":
+          TYPE: vertex_feature
+          NUM_VERTICES: 4936
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_bear_4936_256.pkl"
+DATASETS:
+  TRAIN:
+    - "densepose_lvis_v1_ds2_train_v1"
+  TEST:
+    - "densepose_lvis_v1_ds2_val_v1"
+  WHITELISTED_CATEGORIES:
+    "densepose_lvis_v1_ds2_train_v1":
+      - 943  # sheep
+      - 1202 # zebra
+      - 569  # horse
+      - 496  # giraffe
+      - 422  # elephant
+      - 80   # cow
+      - 76   # bear
+      - 225  # cat
+      - 378  # dog
+    "densepose_lvis_v1_ds2_val_v1":
+      - 943  # sheep
+      - 1202 # zebra
+      - 569  # horse
+      - 496  # giraffe
+      - 422  # elephant
+      - 80   # cow
+      - 76   # bear
+      - 225  # cat
+      - 378  # dog
+  CLASS_TO_MESH_NAME_MAPPING:
+    "0": "bear_4936"
+    "1": "cow_5002"
+    "2": "cat_7466"
+    "3": "dog_7466"
+    "4": "elephant_5002"
+    "5": "giraffe_5002"
+    "6": "horse_5004"
+    "7": "sheep_5004"
+    "8": "zebra_5002"
+SOLVER:
+  MAX_ITER: 24000
+  STEPS: (20000, 22000)

configs/cse/densepose_rcnn_R_50_FPN_soft_chimps_finetune_4k.yaml

@@ -0,0 +1,29 @@
+_BASE_: "Base-DensePose-RCNN-FPN.yaml"
+MODEL:
+  WEIGHTS: "https://dl.fbaipublicfiles.com/densepose/cse/densepose_rcnn_R_50_FPN_soft_s1x/250533982/model_final_2c4512.pkl"
+  RESNETS:
+    DEPTH: 50
+  ROI_DENSEPOSE_HEAD:
+    NAME: "DensePoseV1ConvXHead"
+    CSE:
+      EMBED_LOSS_NAME: "SoftEmbeddingLoss"
+      EMBEDDING_DIST_GAUSS_SIGMA: 0.1
+      GEODESIC_DIST_GAUSS_SIGMA: 0.1
+      EMBEDDERS:
+        "chimp_5029":
+          TYPE: vertex_feature
+          NUM_VERTICES: 5029
+          FEATURE_DIM: 256
+          FEATURES_TRAINABLE: False
+          IS_TRAINABLE: True
+          INIT_FILE: "https://dl.fbaipublicfiles.com/densepose/data/cse/lbo/phi_chimp_5029_256.pkl"
+DATASETS:
+  TRAIN:
+    - "densepose_chimps_cse_train"
+  TEST:
+    - "densepose_chimps_cse_val"
+  CLASS_TO_MESH_NAME_MAPPING:
+    "0": "chimp_5029"
+SOLVER:
+  MAX_ITER: 4000
+  STEPS: (3000, 3500)

configs/cse/densepose_rcnn_R_50_FPN_soft_s1x.yaml

@@ -0,0 +1,12 @@
+_BASE_: "Base-DensePose-RCNN-FPN-Human.yaml"
+MODEL:
+  WEIGHTS: "detectron2://ImageNetPretrained/MSRA/R-50.pkl"
+  RESNETS:
+    DEPTH: 50
+  ROI_DENSEPOSE_HEAD:
+    NAME: "DensePoseV1ConvXHead"
+    CSE:
+      EMBED_LOSS_NAME: "SoftEmbeddingLoss"
+SOLVER:
+  MAX_ITER: 130000
+  STEPS: (100000, 120000)

configs/densepose_rcnn_R_101_FPN_DL_WC1M_s1x.yaml

@@ -0,0 +1,18 @@
+_BASE_: "Base-DensePose-RCNN-FPN.yaml"
+MODEL:
+  WEIGHTS: "detectron2://ImageNetPretrained/MSRA/R-101.pkl"
+  RESNETS:
+    DEPTH: 101
+  ROI_DENSEPOSE_HEAD:
+    NAME: "DensePoseDeepLabHead"
+    UV_CONFIDENCE:
+      ENABLED: True
+      TYPE: "iid_iso"
+    SEGM_CONFIDENCE:
+      ENABLED: True
+    POINT_REGRESSION_WEIGHTS: 0.0005
+SOLVER:
+  CLIP_GRADIENTS:
+    ENABLED: True
+  MAX_ITER: 130000
+  STEPS: (100000, 120000)

configs/densepose_rcnn_R_101_FPN_DL_WC1_s1x.yaml

@@ -0,0 +1,16 @@
+_BASE_: "Base-DensePose-RCNN-FPN.yaml"
+MODEL:
+  WEIGHTS: "detectron2://ImageNetPretrained/MSRA/R-101.pkl"
+  RESNETS:
+    DEPTH: 101
+  ROI_DENSEPOSE_HEAD:
+    NAME: "DensePoseDeepLabHead"
+    UV_CONFIDENCE:
+      ENABLED: True
+      TYPE: "iid_iso"
+    POINT_REGRESSION_WEIGHTS: 0.0005
+SOLVER:
+  CLIP_GRADIENTS:
+    ENABLED: True
+  MAX_ITER: 130000
+  STEPS: (100000, 120000)

configs/densepose_rcnn_R_101_FPN_DL_WC2M_s1x.yaml

@@ -0,0 +1,18 @@
+_BASE_: "Base-DensePose-RCNN-FPN.yaml"
+MODEL:
+  WEIGHTS: "detectron2://ImageNetPretrained/MSRA/R-101.pkl"
+  RESNETS:
+    DEPTH: 101
+  ROI_DENSEPOSE_HEAD:
+    NAME: "DensePoseDeepLabHead"
+    UV_CONFIDENCE:
+      ENABLED: True
+      TYPE: "indep_aniso"
+    SEGM_CONFIDENCE:
+      ENABLED: True
+    POINT_REGRESSION_WEIGHTS: 0.0005
+SOLVER:
+  CLIP_GRADIENTS:
+    ENABLED: True
+  MAX_ITER: 130000
+  STEPS: (100000, 120000)

configs/densepose_rcnn_R_101_FPN_DL_WC2_s1x.yaml

@@ -0,0 +1,16 @@
+_BASE_: "Base-DensePose-RCNN-FPN.yaml"
+MODEL:
+  WEIGHTS: "detectron2://ImageNetPretrained/MSRA/R-101.pkl"
+  RESNETS:
+    DEPTH: 101
+  ROI_DENSEPOSE_HEAD:
+    NAME: "DensePoseDeepLabHead"
+    UV_CONFIDENCE:
+      ENABLED: True
+      TYPE: "indep_aniso"
+    POINT_REGRESSION_WEIGHTS: 0.0005
+SOLVER:
+  CLIP_GRADIENTS:
+    ENABLED: True
+  MAX_ITER: 130000
+  STEPS: (100000, 120000)

configs/densepose_rcnn_R_101_FPN_DL_s1x.yaml

@@ -0,0 +1,10 @@
+_BASE_: "Base-DensePose-RCNN-FPN.yaml"
+MODEL:
+  WEIGHTS: "detectron2://ImageNetPretrained/MSRA/R-101.pkl"
+  RESNETS:
+    DEPTH: 101
+  ROI_DENSEPOSE_HEAD:
+    NAME: "DensePoseDeepLabHead"
+SOLVER:
+  MAX_ITER: 130000
+  STEPS: (100000, 120000)

configs/densepose_rcnn_R_101_FPN_WC1M_s1x.yaml

@@ -0,0 +1,18 @@
+_BASE_: "Base-DensePose-RCNN-FPN.yaml"
+MODEL:
+  WEIGHTS: "detectron2://ImageNetPretrained/MSRA/R-101.pkl"
+  RESNETS:
+    DEPTH: 101
+  ROI_DENSEPOSE_HEAD:
+    UV_CONFIDENCE:
+      ENABLED: True
+      TYPE: "iid_iso"
+    SEGM_CONFIDENCE:
+      ENABLED: True
+    POINT_REGRESSION_WEIGHTS: 0.0005
+SOLVER:
+  CLIP_GRADIENTS:
+    ENABLED: True
+  MAX_ITER: 130000
+  STEPS: (100000, 120000)
+  WARMUP_FACTOR: 0.025

configs/densepose_rcnn_R_101_FPN_WC1_s1x.yaml

@@ -0,0 +1,16 @@
+_BASE_: "Base-DensePose-RCNN-FPN.yaml"
+MODEL:
+  WEIGHTS: "detectron2://ImageNetPretrained/MSRA/R-101.pkl"
+  RESNETS:
+    DEPTH: 101
+  ROI_DENSEPOSE_HEAD:
+    UV_CONFIDENCE:
+      ENABLED: True
+      TYPE: "iid_iso"
+    POINT_REGRESSION_WEIGHTS: 0.0005
+SOLVER:
+  CLIP_GRADIENTS:
+    ENABLED: True
+  MAX_ITER: 130000
+  STEPS: (100000, 120000)
+  WARMUP_FACTOR: 0.025

configs/densepose_rcnn_R_101_FPN_WC2M_s1x.yaml

@@ -0,0 +1,18 @@
+_BASE_: "Base-DensePose-RCNN-FPN.yaml"
+MODEL:
+  WEIGHTS: "detectron2://ImageNetPretrained/MSRA/R-101.pkl"
+  RESNETS:
+    DEPTH: 101
+  ROI_DENSEPOSE_HEAD:
+    UV_CONFIDENCE:
+      ENABLED: True
+      TYPE: "indep_aniso"
+    SEGM_CONFIDENCE:
+      ENABLED: True
+    POINT_REGRESSION_WEIGHTS: 0.0005
+SOLVER:
+  CLIP_GRADIENTS:
+    ENABLED: True
+  MAX_ITER: 130000
+  STEPS: (100000, 120000)
+  WARMUP_FACTOR: 0.025

configs/densepose_rcnn_R_101_FPN_WC2_s1x.yaml

@@ -0,0 +1,16 @@
+_BASE_: "Base-DensePose-RCNN-FPN.yaml"
+MODEL:
+  WEIGHTS: "detectron2://ImageNetPretrained/MSRA/R-101.pkl"
+  RESNETS:
+    DEPTH: 101
+  ROI_DENSEPOSE_HEAD:
+    UV_CONFIDENCE:
+      ENABLED: True
+      TYPE: "indep_aniso"
+    POINT_REGRESSION_WEIGHTS: 0.0005
+SOLVER:
+  CLIP_GRADIENTS:
+    ENABLED: True
+  MAX_ITER: 130000
+  STEPS: (100000, 120000)
+  WARMUP_FACTOR: 0.025

configs/densepose_rcnn_R_101_FPN_s1x.yaml

@@ -0,0 +1,8 @@
+_BASE_: "Base-DensePose-RCNN-FPN.yaml"
+MODEL:
+  WEIGHTS: "detectron2://ImageNetPretrained/MSRA/R-101.pkl"
+  RESNETS:
+    DEPTH: 101
+SOLVER:
+  MAX_ITER: 130000
+  STEPS: (100000, 120000)

configs/densepose_rcnn_R_101_FPN_s1x_legacy.yaml

@@ -0,0 +1,17 @@
+_BASE_: "Base-DensePose-RCNN-FPN.yaml"
+MODEL:
+  WEIGHTS: "detectron2://ImageNetPretrained/MSRA/R-101.pkl"
+  RESNETS:
+    DEPTH: 101
+  ROI_DENSEPOSE_HEAD:
+    NUM_COARSE_SEGM_CHANNELS: 15
+    POOLER_RESOLUTION: 14
+    HEATMAP_SIZE: 56
+    INDEX_WEIGHTS: 2.0
+    PART_WEIGHTS: 0.3
+    POINT_REGRESSION_WEIGHTS: 0.1
+    DECODER_ON: False
+SOLVER:
+  BASE_LR: 0.002
+  MAX_ITER: 130000
+  STEPS: (100000, 120000)

configs/densepose_rcnn_R_50_FPN_DL_WC1M_s1x.yaml

@@ -0,0 +1,18 @@
+_BASE_: "Base-DensePose-RCNN-FPN.yaml"
+MODEL:
+  WEIGHTS: "detectron2://ImageNetPretrained/MSRA/R-50.pkl"
+  RESNETS:
+    DEPTH: 50
+  ROI_DENSEPOSE_HEAD:
+    NAME: "DensePoseDeepLabHead"
+    UV_CONFIDENCE:
+      ENABLED: True
+      TYPE: "iid_iso"
+    SEGM_CONFIDENCE:
+      ENABLED: True
+    POINT_REGRESSION_WEIGHTS: 0.0005
+SOLVER:
+  CLIP_GRADIENTS:
+    ENABLED: True
+  MAX_ITER: 130000
+  STEPS: (100000, 120000)

configs/densepose_rcnn_R_50_FPN_DL_WC1_s1x.yaml

@@ -0,0 +1,16 @@
+_BASE_: "Base-DensePose-RCNN-FPN.yaml"
+MODEL:
+  WEIGHTS: "detectron2://ImageNetPretrained/MSRA/R-50.pkl"
+  RESNETS:
+    DEPTH: 50
+  ROI_DENSEPOSE_HEAD:
+    NAME: "DensePoseDeepLabHead"
+    UV_CONFIDENCE:
+      ENABLED: True
+      TYPE: "iid_iso"
+    POINT_REGRESSION_WEIGHTS: 0.0005
+SOLVER:
+  CLIP_GRADIENTS:
+    ENABLED: True
+  MAX_ITER: 130000
+  STEPS: (100000, 120000)

configs/densepose_rcnn_R_50_FPN_DL_WC2M_s1x.yaml

@@ -0,0 +1,18 @@
+_BASE_: "Base-DensePose-RCNN-FPN.yaml"
+MODEL:
+  WEIGHTS: "detectron2://ImageNetPretrained/MSRA/R-50.pkl"
+  RESNETS:
+    DEPTH: 50
+  ROI_DENSEPOSE_HEAD:
+    NAME: "DensePoseDeepLabHead"
+    UV_CONFIDENCE:
+      ENABLED: True
+      TYPE: "indep_aniso"
+    SEGM_CONFIDENCE:
+      ENABLED: True
+    POINT_REGRESSION_WEIGHTS: 0.0005
+SOLVER:
+  CLIP_GRADIENTS:
+    ENABLED: True
+  MAX_ITER: 130000
+  STEPS: (100000, 120000)

configs/densepose_rcnn_R_50_FPN_DL_WC2_s1x.yaml

@@ -0,0 +1,16 @@
+_BASE_: "Base-DensePose-RCNN-FPN.yaml"
+MODEL:
+  WEIGHTS: "detectron2://ImageNetPretrained/MSRA/R-50.pkl"
+  RESNETS:
+    DEPTH: 50
+  ROI_DENSEPOSE_HEAD:
+    NAME: "DensePoseDeepLabHead"
+    UV_CONFIDENCE:
+      ENABLED: True
+      TYPE: "indep_aniso"
+    POINT_REGRESSION_WEIGHTS: 0.0005
+SOLVER:
+  CLIP_GRADIENTS:
+    ENABLED: True
+  MAX_ITER: 130000
+  STEPS: (100000, 120000)

configs/densepose_rcnn_R_50_FPN_DL_s1x.yaml

@@ -0,0 +1,10 @@
+_BASE_: "Base-DensePose-RCNN-FPN.yaml"
+MODEL:
+  WEIGHTS: "detectron2://ImageNetPretrained/MSRA/R-50.pkl"
+  RESNETS:
+    DEPTH: 50
+  ROI_DENSEPOSE_HEAD:
+    NAME: "DensePoseDeepLabHead"
+SOLVER:
+  MAX_ITER: 130000
+  STEPS: (100000, 120000)