Hugging Face's logo

Spaces:
hysts
/
ibug-face_parsing
Running on Zero

App Files Community
ibug-face_parsing
File size: 4,739 Bytes 
24679fa
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
e58034d
addb396
24679fa
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
 
#!/usr/bin/env python

from __future__ import annotations

import argparse
import functools
import os
import pathlib
import sys
import tarfile

import gradio as gr
import huggingface_hub
import numpy as np
import torch

sys.path.insert(0, 'face_detection')
sys.path.insert(0, 'face_parsing')
sys.path.insert(0, 'roi_tanh_warping')

from ibug.face_detection import RetinaFacePredictor
from ibug.face_parsing.parser import WEIGHT, FaceParser
from ibug.face_parsing.utils import label_colormap

TITLE = 'hhj1897/face_parsing'
DESCRIPTION = 'This is an unofficial demo for https://github.com/hhj1897/face_parsing.'
ARTICLE = '<center><img src="https://visitor-badge.glitch.me/badge?page_id=hysts.ibug-face_parsing" alt="visitor badge"/></center>'

TOKEN = os.environ['TOKEN']


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser()
    parser.add_argument('--device', type=str, default='cpu')
    parser.add_argument('--theme', type=str)
    parser.add_argument('--live', action='store_true')
    parser.add_argument('--share', action='store_true')
    parser.add_argument('--port', type=int)
    parser.add_argument('--disable-queue',
                        dest='enable_queue',
                        action='store_false')
    parser.add_argument('--allow-flagging', type=str, default='never')
    return parser.parse_args()


def load_sample_images() -> list[pathlib.Path]:
    image_dir = pathlib.Path('images')
    if not image_dir.exists():
        image_dir.mkdir()
        dataset_repo = 'hysts/input-images'
        filenames = ['000.tar', '001.tar']
        for name in filenames:
            path = huggingface_hub.hf_hub_download(dataset_repo,
                                                   name,
                                                   repo_type='dataset',
                                                   use_auth_token=TOKEN)
            with tarfile.open(path) as f:
                f.extractall(image_dir.as_posix())
    return sorted(image_dir.rglob('*.jpg'))


def load_detector(device: torch.device) -> RetinaFacePredictor:
    model = RetinaFacePredictor(
        threshold=0.8,
        device=device,
        model=RetinaFacePredictor.get_model('mobilenet0.25'))
    return model


def load_model(model_name: str, device: torch.device) -> FaceParser:
    encoder, decoder, num_classes = model_name.split('-')
    num_classes = int(num_classes)
    model = FaceParser(device=device,
                       encoder=encoder,
                       decoder=decoder,
                       num_classes=num_classes)
    model.num_classes = num_classes
    return model


def predict(image: np.ndarray, model_name: str, max_num_faces: int,
            detector: RetinaFacePredictor,
            models: dict[str, FaceParser]) -> np.ndarray:
    model = models[model_name]
    colormap = label_colormap(model.num_classes)

    # RGB -> BGR
    image = image[:, :, ::-1]

    faces = detector(image, rgb=False)
    if len(faces) == 0:
        raise RuntimeError('No face was found.')
    faces = sorted(list(faces), key=lambda x: -x[4])[:max_num_faces][::-1]
    masks = model.predict_img(image, faces, rgb=False)

    mask_image = np.zeros_like(image)
    for mask in masks:
        temp = colormap[mask]
        mask_image[temp > 0] = temp[temp > 0]

    res = image.astype(float) * 0.5 + mask_image[:, :, ::-1] * 0.5
    res = np.clip(np.round(res), 0, 255).astype(np.uint8)
    return res[:, :, ::-1]


def main():
    args = parse_args()
    device = torch.device(args.device)

    detector = load_detector(device)

    model_names = list(WEIGHT.keys())
    models = {name: load_model(name, device=device) for name in model_names}

    func = functools.partial(predict, detector=detector, models=models)
    func = functools.update_wrapper(func, predict)

    image_paths = load_sample_images()
    examples = [[path.as_posix(), model_names[1], 10] for path in image_paths]

    gr.Interface(
        func,
        [
            gr.inputs.Image(type='numpy', label='Input'),
            gr.inputs.Radio(model_names,
                            type='value',
                            default=model_names[1],
                            label='Model'),
            gr.inputs.Slider(
                1, 20, step=1, default=10, label='Max Number of Faces'),
        ],
        gr.outputs.Image(type='numpy', label='Output'),
        examples=examples,
        title=TITLE,
        description=DESCRIPTION,
        article=ARTICLE,
        theme=args.theme,
        allow_flagging=args.allow_flagging,
        live=args.live,
    ).launch(
        enable_queue=args.enable_queue,
        server_port=args.port,
        share=args.share,
    )


if __name__ == '__main__':
    main()