update

stylegan_human/PP_HumanSeg/export_model/download_export_model.py

+# coding: utf8
+# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import sys
+import os
+
+LOCAL_PATH = os.path.dirname(os.path.abspath(__file__))
+TEST_PATH = os.path.join(LOCAL_PATH, "../../../", "test")
+sys.path.append(TEST_PATH)
+
+from paddleseg.utils.download import download_file_and_uncompress
+
+model_urls = {
+    "pphumanseg_lite_portrait_398x224_with_softmax":
+    "https://paddleseg.bj.bcebos.com/dygraph/ppseg/ppseg_lite_portrait_398x224_with_softmax.tar.gz",
+    "deeplabv3p_resnet50_os8_humanseg_512x512_100k_with_softmax":
+    "https://paddleseg.bj.bcebos.com/dygraph/humanseg/export/deeplabv3p_resnet50_os8_humanseg_512x512_100k_with_softmax.zip",
+    "fcn_hrnetw18_small_v1_humanseg_192x192_with_softmax":
+    "https://paddleseg.bj.bcebos.com/dygraph/humanseg/export/fcn_hrnetw18_small_v1_humanseg_192x192_with_softmax.zip",
+    "pphumanseg_lite_generic_humanseg_192x192_with_softmax":
+    "https://paddleseg.bj.bcebos.com/dygraph/humanseg/export/pphumanseg_lite_generic_192x192_with_softmax.zip",
+}
+
+if __name__ == "__main__":
+    for model_name, url in model_urls.items():
+        download_file_and_uncompress(
+            url=url,
+            savepath=LOCAL_PATH,
+            extrapath=LOCAL_PATH,
+            extraname=model_name)
+
+    print("Export model download success!")

stylegan_human/PP_HumanSeg/pretrained_model/download_pretrained_model.py

+# coding: utf8
+# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import sys
+import os
+
+LOCAL_PATH = os.path.dirname(os.path.abspath(__file__))
+TEST_PATH = os.path.join(LOCAL_PATH, "../../../", "test")
+sys.path.append(TEST_PATH)
+
+from paddleseg.utils.download import download_file_and_uncompress
+
+model_urls = {
+    "pphumanseg_lite_portrait_398x224":
+    "https://paddleseg.bj.bcebos.com/dygraph/ppseg/ppseg_lite_portrait_398x224.tar.gz",
+    "deeplabv3p_resnet50_os8_humanseg_512x512_100k":
+    "https://paddleseg.bj.bcebos.com/dygraph/humanseg/train/deeplabv3p_resnet50_os8_humanseg_512x512_100k.zip",
+    "fcn_hrnetw18_small_v1_humanseg_192x192":
+    "https://paddleseg.bj.bcebos.com/dygraph/humanseg/train/fcn_hrnetw18_small_v1_humanseg_192x192.zip",
+    "pphumanseg_lite_generic_human_192x192":
+    "https://paddleseg.bj.bcebos.com/dygraph/humanseg/train/pphumanseg_lite_generic_192x192.zip",
+}
+
+if __name__ == "__main__":
+    for model_name, url in model_urls.items():
+        download_file_and_uncompress(
+            url=url,
+            savepath=LOCAL_PATH,
+            extrapath=LOCAL_PATH,
+            extraname=model_name)
+
+    print("Pretrained model download success!")

stylegan_human/README.md

+# StyleGAN-Human:  A Data-Centric Odyssey of Human Generation
+<img src="./img/demo_V5_thumbnails-min.png" width="96%" height="96%">
+
+<!--
+**stylegan-human/StyleGAN-Human** is a ✨ _special_ ✨ repository because its `README.md` (this file) appears on your GitHub profile.
+
+-->
+
+> 
+>
+> **Abstract:** *Unconditional human image generation is an important task in vision and graphics, which enables various applications in the creative industry. Existing studies in this field mainly focus on "network engineering" such as designing new components and objective functions. This work takes a data-centric perspective and investigates multiple critical aspects in "data engineering", which we believe would complement the current practice. To facilitate a comprehensive study, we collect and annotate a large-scale human image dataset with over 230K samples capturing diverse poses and textures. Equipped with this large dataset, we rigorously investigate three essential factors in data engineering for StyleGAN-based human generation, namely data size, data distribution, and data alignment. Extensive experiments reveal several valuable observations w.r.t. these aspects: 1) Large-scale data, more than 40K images, are needed to train a high-fidelity unconditional human generation model with vanilla StyleGAN. 2) A balanced training set helps improve the generation quality with rare face poses compared to the long-tailed counterpart, whereas simply balancing the clothing texture distribution does not effectively bring an improvement. 3) Human GAN models with body centers for alignment outperform models trained using face centers or pelvis points as alignment anchors. In addition, a model zoo and human editing applications are demonstrated to facilitate future research in the community.* <br>
+**Keyword:** Human Image Generation, Data-Centric, StyleGAN
+ 
+[Jianglin Fu](mailto:fujianglin@sensetime.com), [Shikai Li](mailto:lishikai@sensetime.com), [Yuming Jiang](https://yumingj.github.io/), [Kwan-Yee Lin](https://kwanyeelin.github.io/), [Chen Qian](https://scholar.google.com/citations?user=AerkT0YAAAAJ&hl=zh-CN), [Chen Change Loy](https://www.mmlab-ntu.com/person/ccloy/), [Wayne Wu](https://wywu.github.io/), and [Ziwei Liu](https://liuziwei7.github.io/) <br>
+**[[Demo Video]](https://youtu.be/nIrb9hwsdcI)** | **[[Project Page]](https://stylegan-human.github.io/)** | **[[Paper]](https://arxiv.org/pdf/2204.11823.pdf)**
+
+## Updates
+- [20/07/2022] [SHHQ-1.0](./docs/Dataset.md) dataset with 40K images is released! :sparkles:
+- [15/06/2022] Data alignment and real-image inversion scripts are released. 
+- [26/04/2022] Technical report released!
+- [22/04/2022] Technical report will be released before May.
+- [21/04/2022] The codebase and project page are created.
+
+## Data Download
+The first version SHHQ-1.0, with 40K images is released. To download and use the dataset set, please read the instructions in [Dataset.md](./docs/Dataset.md)
+
+（We are currently facing large incoming applications, and we need to carefully verify all the applicants, please be patient, and we will reply to you as soon as possible.）
+
+## Model Zoo
+
+| Structure | 1024x512 | Metric | Scores |  512x256 | Metric | Scores | 
+| --------- |:----------:| :----------:| :----------:|  :-----: |  :-----: |  :-----: | 
+| StyleGAN1 |[stylegan_human_v1_1024.pkl](https://drive.google.com/file/d/1h-R-IV-INGdPEzj4P9ml6JTEvihuNgLX/view?usp=sharing)| fid50k | 3.79 | to be released | - | - |
+| StyleGAN2 |[stylegan_human_v2_1024.pkl](https://drive.google.com/file/d/1FlAb1rYa0r_--Zj_ML8e6shmaF28hQb5/view?usp=sharing)| fid50k_full | 1.57 |[stylegan_human_v2_512.pkl](https://drive.google.com/file/d/1dlFEHbu-WzQWJl7nBBZYcTyo000H9hVm/view?usp=sharing) | fid50k_full | 1.97 |
+| StyleGAN3 |to be released | - | - |  [stylegan_human_v3_512.pkl](https://drive.google.com/file/d/1_274jk_N6WSCkKWeu7hjHycqGvbuOFf5/view?usp=sharing) | fid50k_full | 2.54 |
+
+
+
+## Web Demo 
+
+Integrated into [Huggingface Spaces 🤗](https://huggingface.co/spaces) using [Gradio](https://github.com/gradio-app/gradio). Try out the Web Demo for generation: [![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/hysts/StyleGAN-Human) and interpolation [![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/hysts/StyleGAN-Human-Interpolation)
+
+
+
+<a href="https://colab.research.google.com/drive/1sgxoDM55iM07FS54vz9ALg1XckiYA2On"><img src="https://colab.research.google.com/assets/colab-badge.svg" height=22.5></a> 
+
+We prepare a Colab demo to allow you to synthesize images with the provided models, as well as visualize the performance of style-mixing, interpolation, and attributes editing.
+The notebook will guide you to install the necessary environment and download pretrained models. The output images can be found in `./StyleGAN-Human/outputs/`.
+Hope you enjoy!
+
+## Usage
+
+### System requirements
+* The original code bases are [stylegan (tensorflow)](https://github.com/NVlabs/stylegan), [stylegan2-ada (pytorch)](https://github.com/NVlabs/stylegan2-ada-pytorch), [stylegan3 (pytorch)](https://github.com/NVlabs/stylegan3), released by NVidia
+
+* We tested in Python 3.8.5 and PyTorch 1.9.1 with CUDA 11.1. (See https://pytorch.org for PyTorch install instructions.)
+
+### Installation
+To work with this project on your own machine, you need to install the environmnet as follows: 
+
+```
+conda env create -f environment.yml
+conda activate stylehuman
+# [Optional: tensorflow 1.x is required for StyleGAN1. ]
+pip install nvidia-pyindex
+pip install nvidia-tensorflow[horovod]
+pip install nvidia-tensorboard==1.15
+```
+Extra notes:
+1. In case having some conflicts when calling CUDA version, please try to empty the LD_LIBRARY_PATH. For example:
+```
+LD_LIBRARY_PATH=; python generate.py --outdir=out/stylegan_human_v2_1024 --trunc=1 --seeds=1,3,5,7 
+--network=pretrained_models/stylegan_human_v2_1024.pkl --version 2
+```
+
+
+2. We found the following troubleshooting links might be helpful: [1.](https://github.com/NVlabs/stylegan3), [2.](https://github.com/NVlabs/stylegan3/blob/main/docs/troubleshooting.md)
+
+### Train
+The training scripts are based on the original [stylegan1](https://github.com/NVlabs/stylegan), [stylegan2-ada](https://github.com/NVlabs/stylegan2-ada-pytorch), and [stylegan3](https://github.com/NVlabs/stylegan3) with minor changes. Here we only provide the scripts with modifications for SG2 and SG3. You can replace the old files with the provided scripts to train. (assume SHHQ-1.0 is placed under data/)
+
+#### Train Stylegan2-ada-pytorch with SHHQ-1.0
+```
+python train.py --outdir=training_results/sg2/ --data=data/SHHQ-1.0/ \
+    --gpus=8 --aug=noaug --mirror=1 --snap=250 --cfg=shhq --square=False
+```
+#### Train Stylegan3 with SHHQ-1.0 
+```
+python train.py --outdir=training_results/sg3/ --cfg=stylegan3-r --gpus=8 --batch=32 --gamma=12.4 \
+    --mirror=1 --aug=noaug --data=data/SHHQ-1.0/ --square=False --snap=250
+```
+
+### Pretrained models
+Please put the downloaded pretrained models [from above link](#Model-Zoo) under the folder 'pretrained_models'.
+
+
+### Generate full-body human images using our pretrained model
+```
+# Generate human full-body images without truncation
+python generate.py --outdir=outputs/generate/stylegan_human_v2_1024 --trunc=1 --seeds=1,3,5,7 --network=pretrained_models/stylegan_human_v2_1024.pkl --version 2
+
+# Generate human full-body images with truncation 
+python generate.py --outdir=outputs/generate/stylegan_human_v2_1024 --trunc=0.8 --seeds=0-10 --network=pretrained_models/stylegan_human_v2_1024.pkl --version 2
+
+# Generate human full-body images using stylegan V1
+python generate.py --outdir=outputs/generate/stylegan_human_v1_1024 --network=pretrained_models/stylegan_human_v1_1024.pkl --version 1 --seeds=1,3,5
+
+# Generate human full-body images using stylegan V3
+python generate.py --outdir=outputs/generate/stylegan_human_v3_512 --network=pretrained_models/stylegan_human_v3_512.pkl --version 3 --seeds=1,3,5
+```
+
+
+#### Note: The following demos are generated based on models related to StyleGAN V2 (stylegan_human_v2_512.pkl and stylegan_human_v2_1024.pkl). If you want to see results for V1 or V3, you need to change the loading method of the corresponding models.
+
+
+### Interpolation
+```
+python interpolation.py --network=pretrained_models/stylegan_human_v2_1024.pkl  --seeds=85,100 --outdir=outputs/inter_gifs
+```
+
+### Style-mixing **image** using stylegan2
+```
+python style_mixing.py --network=pretrained_models/stylegan_human_v2_1024.pkl --rows=85,100,75,458,1500 \\
+    --cols=55,821,1789,293 --styles=0-3 --outdir=outputs/stylemixing 
+```
+
+### Style-mixing **video** using stylegan2
+```
+python stylemixing_video.py --network=pretrained_models/stylegan_human_v2_1024.pkl --row-seed=3859 \\
+    --col-seeds=3098,31759,3791 --col-styles=8-12 --trunc=0.8 --outdir=outputs/stylemixing_video
+```
+
+### Aligned raw images
+For alignment, we use [openpose-pytorch](https://github.com/Hzzone/pytorch-openpose) for body-keypoints detection and [PaddlePaddle](https://github.com/PaddlePaddle/PaddleSeg/tree/release/2.5/contrib/PP-HumanSeg) for human segmentation.
+Before running the alignment script, few models need to be installed:
+1. download [body_pose_model.pth](https://drive.google.com/drive/folders/1JsvI4M4ZTg98fmnCZLFM-3TeovnCRElG?usp=sharing) and place it into openpose/model/.
+2. download and extract [deeplabv3p_resnet50_os8_humanseg_512x512_100k_with_softmax](https://paddleseg.bj.bcebos.com/dygraph/humanseg/export/deeplabv3p_resnet50_os8_humanseg_512x512_100k_with_softmax.zip) into PP_HumanSeg/export_model/deeplabv3p_resnet50_os8_humanseg_512x512_100k_with_softmax.
+3. download and extract [deeplabv3p_resnet50_os8_humanseg_512x512_100k](https://paddleseg.bj.bcebos.com/dygraph/humanseg/train/deeplabv3p_resnet50_os8_humanseg_512x512_100k.zip) into PP_HumanSeg/pretrained_model/deeplabv3p_resnet50_os8_humanseg_512x512_100k.
+4. install paddlepaddel: ``` pip install paddleseg ```
+
+Then you can start alignment: 
+```
+python alignment.py --image-folder img/test/ --output-folder aligned_image/
+```
+
+### Invert real image with [PTI](https://github.com/danielroich/PTI)
+Before inversion, please download our PTI weights: [e4e_w+.pt](https://drive.google.com/file/d/1NUfSJqLhsrU7c9PwAtlZ9xtrxhzS_6tu/view?usp=sharing) into /pti/.
+
+Few parameters you can change:
+- /pti/pti_configs/hyperparameters.py:
+    - first_inv_type = 'w+' -> Use pretrained e4e encoder
+    - first_inv_type = 'w'  -> Use projection and optimization
+- /pti/pti_configs/paths_config.py:
+    - input_data_path: path of real images
+    - e4e: path of e4e_w+.pt
+    - stylegan2_ada_shhq: pretrained stylegan2-ada model for SHHQ
+
+```
+python run_pti.py
+```
+Note: we used the test image under 'aligned_image/' (the output of alignment.py), the inverted latent code and fine-tuned generator will be saved in 'outputs/pti/'
+
+
+### Editing with InterfaceGAN, StyleSpace, and Sefa
+```
+python edit.py --network pretrained_models/stylegan_human_v2_1024.pkl --attr_name upper_length \\
+    --seeds 61531,61570,61571,61610 --outdir outputs/edit_results
+``` 
+
+### Editing using inverted latent code
+```
+python edit.py ---network outputs/pti/checkpoints/model_test.pkl --attr_name upper_length \\
+    --outdir outputs/edit_results --real True --real_w_path outputs/pti/embeddings/test/PTI/test/0.pt --real_img_path aligned_image/test.png
+```
+
+Note: 
+1. ''upper_length'' and ''bottom_length'' of ''attr_name'' are available for demo.
+2. Layers to control and editing strength are set in edit/edit_config.py.
+
+
+### Demo for [InsetGAN](https://arxiv.org/abs/2203.07293)
+
+We implement a quick demo using the key idea from InsetGAN: combining the face generated by FFHQ with the human-body generated by our pretrained model, optimizing both face and body latent codes to get a coherent full-body image.
+Before running the script, you need to download the [FFHQ face model]( https://docs.google.com/uc?export=download&confirm=t&id=125OG7SMkXI-Kf2aqiwLLHyCvSW-gZk3M), or you can use your own face model, as well as [pretrained face landmark](https://docs.google.com/uc?export=download&confirm=&id=1A82DnJBJzt8wI2J8ZrCK5fgHcQ2-tcWM) and [pretrained CNN face detection model for dlib](https://docs.google.com/uc?export=download&confirm=&id=1MduBgju5KFNrQfDLoQXJ_1_h5MnctCIG)
+```
+python insetgan.py --body_network=pretrained_models/stylegan_human_v2_1024.pkl --face_network=pretrained_models/ffhq.pkl \\
+    --body_seed=82 --face_seed=43  --trunc=0.6 --outdir=outputs/insetgan/ --video 1 
+```
+
+## Results
+
+### Editing with inverted real image
+(from left to right: real image | inverted image | InterFaceGAN result | StyleSpace result | SeFa result)
+
+https://user-images.githubusercontent.com/98547009/173773800-bb7fe54a-84d3-4b30-9864-a6b7b311f8ff.mp4
+
+
+### For more demo, please visit our [**web page**](https://stylegan-human.github.io/) .
+  
+
+## TODO List
+
+- [ ] Release 1024x512 version of StyleGAN-Human based on StyleGAN3 
+- [ ] Release 512x256 version of StyleGAN-Human based on StyleGAN1 
+- [ ] Extension of downstream application (InsetGAN): Add face inversion interface to support fusing user face image and stylegen-human body image
+- [x] Add Inversion Script into the provided editing pipeline
+- [ ] Release Dataset
+
+
+## Related Works
+* (SIGGRAPH 2022) **Text2Human: Text-Driven Controllable Human Image Generation**, Yuming Jiang et al. [[Paper](https://arxiv.org/pdf/2205.15996.pdf)], [[Code](https://github.com/yumingj/Text2Human)], [[Project Page](https://yumingj.github.io/projects/Text2Human.html)], [[Dataset](https://github.com/yumingj/DeepFashion-MultiModal)]
+* (ICCV 2021) **Talk-to-Edit: Fine-Grained Facial Editing via Dialog**, Yuming Jiang et al. [[Paper](https://arxiv.org/abs/2109.04425)], [[Code](https://github.com/yumingj/Talk-to-Edit)], [[Project Page](https://www.mmlab-ntu.com/project/talkedit/)], [[Dataset](https://mmlab.ie.cuhk.edu.hk/projects/CelebA/CelebA_Dialog.html)]
+* (Technical Report 2022) **Generalizable Neural Performer: Learning Robust Radiance Fields for Human Novel View Synthesis**, Wei Cheng et al. [[Paper](https://arxiv.org/pdf/2204.11798.pdf)], [[Code](https://github.com/generalizable-neural-performer/gnr)], [[Project Page](https://generalizable-neural-performer.github.io/)], [[Dataset](https://generalizable-neural-performer.github.io/genebody.html)]
+
+## Citation
+
+If you find this work useful for your research, please consider citing our paper:
+
+```bibtex
+@article{fu2022styleganhuman,
+      title={StyleGAN-Human: A Data-Centric Odyssey of Human Generation}, 
+      author={Fu, Jianglin and Li, Shikai and Jiang, Yuming and Lin, Kwan-Yee and Qian, Chen and Loy, Chen-Change and Wu, Wayne and Liu, Ziwei},
+      journal   = {arXiv preprint},
+      volume    = {arXiv:2204.11823},
+      year    = {2022}
+```
+
+## Acknowlegement
+Part of the code is borrowed from [stylegan (tensorflow)](https://github.com/NVlabs/stylegan), [stylegan2-ada (pytorch)](https://github.com/NVlabs/stylegan2-ada-pytorch), [stylegan3 (pytorch)](https://github.com/NVlabs/stylegan3).

stylegan_human/alignment.py

+# Copyright (c) SenseTime Research. All rights reserved.
+
+
+import os
+import argparse 
+import numpy as np
+import torch
+from torch.utils.data import DataLoader
+from torchvision.transforms import transforms
+from utils.ImagesDataset import ImagesDataset
+
+import cv2
+import time
+import copy
+import imutils
+
+# for openpose body keypoint detector : # (src:https://github.com/Hzzone/pytorch-openpose)
+from openpose.src import util
+from openpose.src.body import Body
+
+# for paddlepaddle human segmentation : #(src: https://github.com/PaddlePaddle/PaddleSeg/blob/release/2.5/contrib/PP-HumanSeg/)
+from PP_HumanSeg.deploy.infer import Predictor as PP_HumenSeg_Predictor
+
+import math
+def angle_between_points(p0,p1,p2):
+    if p0[1]==-1 or p1[1]==-1 or p2[1]==-1:
+        return -1
+    a = (p1[0]-p0[0])**2 + (p1[1]-p0[1])**2
+    b = (p1[0]-p2[0])**2 + (p1[1]-p2[1])**2
+    c = (p2[0]-p0[0])**2 + (p2[1]-p0[1])**2 
+    if a * b == 0:
+        return -1
+    return math.acos((a+b-c) / math.sqrt(4*a*b)) * 180 / math.pi
+
+
+def crop_img_with_padding(img, keypoints, rect):
+    person_xmin,person_xmax, ymin, ymax= rect
+    img_h,img_w,_ = img.shape    ## find body center using keypoints
+    middle_shoulder_x = keypoints[1][0]
+    middle_hip_x = (keypoints[8][0] + keypoints[11][0]) // 2
+    mid_x = (middle_hip_x + middle_shoulder_x) // 2    
+    mid_y = (ymin + ymax) // 2
+    ## find which side (l or r) is further than center x, use the further side
+    if abs(mid_x-person_xmin) > abs(person_xmax-mid_x): #left further
+        xmin = person_xmin
+        xmax = mid_x + (mid_x-person_xmin)
+    else:
+        ############### may be negtive
+        ### in this case, the script won't output any image, leave the case like this
+        ### since we don't want to pad human body
+        xmin = mid_x - (person_xmax-mid_x)   
+        xmax = person_xmax 
+
+    w = xmax - xmin
+    h = ymax - ymin
+    ## pad rectangle to w:h = 1:2 ## calculate desired border length
+    if h / w >= 2: #pad horizontally
+        target_w = h // 2
+        xmin_prime = int(mid_x - target_w / 2)
+        xmax_prime = int(mid_x + target_w / 2)
+        if xmin_prime < 0:
+            pad_left = abs(xmin_prime)# - xmin
+            xmin = 0
+        else:
+            pad_left = 0
+            xmin = xmin_prime
+        if xmax_prime > img_w:
+            pad_right = xmax_prime - img_w
+            xmax = img_w
+        else:
+            pad_right = 0
+            xmax = xmax_prime
+
+        cropped_img = img[int(ymin):int(ymax), int(xmin):int(xmax)]
+        im_pad = cv2.copyMakeBorder(cropped_img, 0, 0, int(pad_left),  int(pad_right), cv2.BORDER_REPLICATE) 
+    else: #pad vertically
+        target_h = w * 2
+        ymin_prime = mid_y - (target_h / 2)
+        ymax_prime = mid_y + (target_h / 2) 
+        if ymin_prime < 0: 
+            pad_up = abs(ymin_prime)# - ymin
+            ymin = 0
+        else:
+            pad_up = 0
+            ymin = ymin_prime
+        if ymax_prime > img_h:
+            pad_down = ymax_prime - img_h
+            ymax = img_h
+        else:
+            pad_down = 0
+            ymax = ymax_prime
+        print(ymin,ymax, xmin,xmax, img.shape)
+
+        cropped_img = img[int(ymin):int(ymax), int(xmin):int(xmax)]
+        im_pad = cv2.copyMakeBorder(cropped_img, int(pad_up), int(pad_down), 0,
+                                    0, cv2.BORDER_REPLICATE) 
+    result = cv2.resize(im_pad,(512,1024),interpolation = cv2.INTER_AREA)
+    return result
+
+
+def run(args):
+    os.makedirs(args.output_folder, exist_ok=True)
+    dataset = ImagesDataset(args.image_folder, transforms.Compose([transforms.ToTensor()]))
+    dataloader = DataLoader(dataset, batch_size=1, shuffle=False)
+
+    body_estimation = Body('openpose/model/body_pose_model.pth')
+
+    total = len(dataloader)
+    print('Num of dataloader : ', total)
+    os.makedirs(f'{args.output_folder}', exist_ok=True)
+    # os.makedirs(f'{args.output_folder}/middle_result', exist_ok=True)
+    
+    ## initialzide HumenSeg
+    human_seg_args = {}
+    human_seg_args['cfg'] = 'PP_HumanSeg/export_model/deeplabv3p_resnet50_os8_humanseg_512x512_100k_with_softmax/deploy.yaml'
+    human_seg_args['input_shape'] = [1024,512]
+    human_seg_args['save_dir'] = args.output_folder
+    human_seg_args['soft_predict'] = False
+    human_seg_args['use_gpu'] = True
+    human_seg_args['test_speed'] = False
+    human_seg_args['use_optic_flow'] = False
+    human_seg_args['add_argmax'] = True
+    human_seg_args= argparse.Namespace(**human_seg_args)
+    human_seg = PP_HumenSeg_Predictor(human_seg_args)
+
+    from tqdm import tqdm
+    for fname, image in tqdm(dataloader):
+        # try:
+        ## tensor to numpy image
+        fname = fname[0]
+        print(f'Processing \'{fname}\'.')
+        
+        image = (image.permute(0, 2, 3, 1) * 255).clamp(0, 255)
+        image = image.squeeze(0).numpy() # --> tensor to numpy, (H,W,C)
+        # avoid super high res img
+        if image.shape[0] >= 2000: # height  ### for shein image
+            ratio = image.shape[0]/1200 #height
+            dim = (int(image.shape[1]/ratio),1200)#(width, height)
+            image = cv2.resize(image, dim, interpolation = cv2.INTER_AREA)
+        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+
+        ## create segmentation
+        # mybg = cv2.imread('mybg.png') 
+        comb, segmentation, bg, ori_img = human_seg.run(image,None)  #mybg) 
+        # cv2.imwrite('comb.png',comb)  # [0,255]
+        # cv2.imwrite('alpha.png',segmentation*255) # segmentation [0,1] --> [0.255]
+        # cv2.imwrite('bg.png',bg)  #[0,255]
+        # cv2.imwrite('ori_img.png',ori_img) # [0,255]
+
+        masks_np = (segmentation* 255)# .byte().cpu().numpy() #1024,512,1
+        mask0_np = masks_np[:,:,0].astype(np.uint8)#[0, :, :]
+        contours = cv2.findContours(mask0_np,  cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        cnts = imutils.grab_contours(contours)
+        c = max(cnts, key=cv2.contourArea)
+        extTop = tuple(c[c[:, :, 1].argmin()][0])
+        extBot = tuple(c[c[:, :, 1].argmax()][0])
+        extBot = list(extBot)
+        extTop = list(extTop)
+        pad_range = int((extBot[1]-extTop[1])*0.05)
+        if (int(extTop[1])<=5 and int(extTop[1])>0) and (comb.shape[0]>int(extBot[1]) and int(extBot[1])>=comb.shape[0]-5): #seg mask already reaches to the edge
+            #pad with pure white, top 100 px, bottom 100 px
+            comb= cv2.copyMakeBorder(comb,pad_range+5,pad_range+5,0,0,cv2.BORDER_CONSTANT,value=[255,255,255]) 
+        elif int(extTop[1])<=0 or int(extBot[1])>=comb.shape[0]:
+            print('PAD: body out of boundary', fname) #should not happened
+            return {}
+        else:
+            comb = cv2.copyMakeBorder(comb, pad_range+5, pad_range+5, 0, 0, cv2.BORDER_REPLICATE) #105 instead of 100: give some extra space
+        extBot[1] = extBot[1] + pad_range+5
+        extTop[1] = extTop[1] + pad_range+5
+
+        extLeft = tuple(c[c[:, :, 0].argmin()][0])
+        extRight = tuple(c[c[:, :, 0].argmax()][0])
+        extLeft = list(extLeft)
+        extRight = list(extRight)
+        person_ymin = int(extTop[1])-pad_range # 100
+        person_ymax = int(extBot[1])+pad_range # 100 #height
+        if person_ymin<0 or person_ymax>comb.shape[0]: # out of range
+            return {}
+        person_xmin = int(extLeft[0])
+        person_xmax = int(extRight[0])
+        rect =  [person_xmin,person_xmax,person_ymin, person_ymax]
+        # recimg = copy.deepcopy(comb)
+        # cv2.rectangle(recimg,(person_xmin,person_ymin),(person_xmax,person_ymax),(0,255,0),2)
+        # cv2.imwrite(f'{args.output_folder}/middle_result/{fname}_rec.png',recimg)
+
+        ## detect keypoints
+        keypoints, subset = body_estimation(comb)
+        # print(keypoints, subset, len(subset))
+        if len(subset) != 1 or (len(subset)==1 and subset[0][-1]<15): 
+            print(f'Processing \'{fname}\'. Please import image contains one person only. Also can check segmentation mask. ')
+            continue
+
+        # canvas = copy.deepcopy(comb)
+        # canvas = util.draw_bodypose(canvas, keypoints, subset, show_number=True)
+        # cv2.imwrite(f'{args.output_folder}/middle_result/{fname}_keypoints.png',canvas)
+
+        comb = crop_img_with_padding(comb, keypoints, rect)
+
+        
+        cv2.imwrite(f'{args.output_folder}/{fname}.png', comb)
+        print(f' -- Finished processing \'{fname}\'. --')
+        # except:
+        #     print(f'Processing \'{fname}\'. Not satisfied the alignment strategy.')
+        
+        
+if __name__ == '__main__':
+    torch.backends.cudnn.benchmark = True
+    torch.backends.cudnn.deterministic = False
+    
+    t1 = time.time()
+    arg_formatter = argparse.ArgumentDefaultsHelpFormatter
+    description = 'StyleGAN-Human data process'
+    parser = argparse.ArgumentParser(formatter_class=arg_formatter,
+                                     description=description)
+    parser.add_argument('--image-folder', type=str, dest='image_folder')
+    parser.add_argument('--output-folder', dest='output_folder', default='results', type=str)
+    # parser.add_argument('--cfg', dest='cfg for segmentation', default='PP_HumanSeg/export_model/ppseg_lite_portrait_398x224_with_softmax/deploy.yaml', type=str)
+
+    print('parsing arguments')
+    cmd_args = parser.parse_args()
+    run(cmd_args)
+
+    print('total time elapsed: ', str(time.time() - t1))
\ No newline at end of file

stylegan_human/bg_white.py

+# Copyright (c) SenseTime Research. All rights reserved.
+
+import os
+import click
+import cv2
+import numpy as np
+
+def bg_white(seg, raw, blur_level=3, gaussian=81):
+    seg = cv2.blur(seg, (blur_level, blur_level))
+
+    empty = np.ones_like(seg)
+    seg_bg = (empty - seg) * 255 
+    seg_bg = cv2.GaussianBlur(seg_bg,(gaussian,gaussian),0)
+
+    background_mask = cv2.cvtColor(255 - cv2.cvtColor(seg, cv2.COLOR_BGR2GRAY), cv2.COLOR_GRAY2BGR)
+    masked_fg = (raw * (1 / 255)) * (seg * (1 / 255))
+    masked_bg = (seg_bg * (1 / 255)) * (background_mask * (1 / 255))
+
+    frame = np.uint8(cv2.add(masked_bg,masked_fg)*255)
+
+    return frame
+
+
+"""
+To turn background into white.
+
+Examples:
+
+\b
+python bg_white.py  --raw_img_dir=./SHHQ-1.0/no_segment/ --raw_seg_dir=./SHHQ-1.0/segments/ \\
+    --outdir=./SHHQ-1.0/bg_white/
+"""
+
+@click.command()
+@click.pass_context
+@click.option('--raw_img_dir', default="./SHHQ-1.0/no_segment/", help='folder of raw image', required=True)
+@click.option('--raw_seg_dir', default='./SHHQ-1.0/segments/', help='folder of segmentation masks', required=True)
+@click.option('--outdir', help='Where to save the output images', default= "./SHHQ-1.0/bg_white/" , type=str, required=True, metavar='DIR')
+
+def main(
+        ctx: click.Context,
+        raw_img_dir: str,
+        raw_seg_dir: str,
+        outdir: str):
+    os.makedirs(outdir, exist_ok=True)
+    files = os.listdir(raw_img_dir)
+    for file in files: 
+        print(file)
+        raw = cv2.imread(os.path.join(raw_img_dir, file))
+        seg = cv2.imread(os.path.join(raw_seg_dir, file))
+        assert raw is not None
+        assert seg is not None
+        white_frame = bg_white(seg, raw)
+        cv2.imwrite(os.path.join(outdir,file), white_frame)
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file

stylegan_human/dnnlib/__init__.py

+# Copyright (c) SenseTime Research. All rights reserved.
+
+# Copyright (c) 2021, NVIDIA CORPORATION.  All rights reserved.
+#
+# NVIDIA CORPORATION and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto.  Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION is strictly prohibited.
+
+from .util import EasyDict, make_cache_dir_path

stylegan_human/dnnlib/tflib/__init__.py

+# Copyright (c) SenseTime Research. All rights reserved.
+
+# Copyright (c) 2019, NVIDIA Corporation. All rights reserved.
+#
+# This work is made available under the Nvidia Source Code License-NC.
+# To view a copy of this license, visit
+# https://nvlabs.github.io/stylegan2/license.html
+
+from . import autosummary
+from . import network
+from . import optimizer
+from . import tfutil
+from . import custom_ops
+
+from .tfutil import *
+from .network import Network
+
+from .optimizer import Optimizer
+
+from .custom_ops import get_plugin

stylegan_human/dnnlib/tflib/autosummary.py

+# Copyright (c) SenseTime Research. All rights reserved.
+
+# Copyright (c) 2019, NVIDIA Corporation. All rights reserved.
+#
+# This work is made available under the Nvidia Source Code License-NC.
+# To view a copy of this license, visit
+# https://nvlabs.github.io/stylegan2/license.html
+
+"""Helper for adding automatically tracked values to Tensorboard.
+
+Autosummary creates an identity op that internally keeps track of the input
+values and automatically shows up in TensorBoard. The reported value
+represents an average over input components. The average is accumulated
+constantly over time and flushed when save_summaries() is called.
+
+Notes:
+- The output tensor must be used as an input for something else in the
+  graph. Otherwise, the autosummary op will not get executed, and the average
+  value will not get accumulated.
+- It is perfectly fine to include autosummaries with the same name in
+  several places throughout the graph, even if they are executed concurrently.
+- It is ok to also pass in a python scalar or numpy array. In this case, it
+  is added to the average immediately.
+"""
+
+from collections import OrderedDict
+import numpy as np
+import tensorflow as tf
+from tensorboard import summary as summary_lib
+from tensorboard.plugins.custom_scalar import layout_pb2
+
+from . import tfutil
+from .tfutil import TfExpression
+from .tfutil import TfExpressionEx
+
+# Enable "Custom scalars" tab in TensorBoard for advanced formatting.
+# Disabled by default to reduce tfevents file size.
+enable_custom_scalars = False
+
+_dtype = tf.float64
+_vars = OrderedDict()  # name => [var, ...]
+_immediate = OrderedDict()  # name => update_op, update_value
+_finalized = False
+_merge_op = None
+
+
+def _create_var(name: str, value_expr: TfExpression) -> TfExpression:
+    """Internal helper for creating autosummary accumulators."""
+    assert not _finalized
+    name_id = name.replace("/", "_")
+    v = tf.cast(value_expr, _dtype)
+
+    if v.shape.is_fully_defined():
+        size = np.prod(v.shape.as_list())
+        size_expr = tf.constant(size, dtype=_dtype)
+    else:
+        size = None
+        size_expr = tf.reduce_prod(tf.cast(tf.shape(v), _dtype))
+
+    if size == 1:
+        if v.shape.ndims != 0:
+            v = tf.reshape(v, [])
+        v = [size_expr, v, tf.square(v)]
+    else:
+        v = [size_expr, tf.reduce_sum(v), tf.reduce_sum(tf.square(v))]
+    v = tf.cond(tf.is_finite(v[1]), lambda: tf.stack(v), lambda: tf.zeros(3, dtype=_dtype))
+
+    with tfutil.absolute_name_scope("Autosummary/" + name_id), tf.control_dependencies(None):
+        var = tf.Variable(tf.zeros(3, dtype=_dtype), trainable=False)  # [sum(1), sum(x), sum(x**2)]
+    update_op = tf.cond(tf.is_variable_initialized(var), lambda: tf.assign_add(var, v), lambda: tf.assign(var, v))
+
+    if name in _vars:
+        _vars[name].append(var)
+    else:
+        _vars[name] = [var]
+    return update_op
+
+
+def autosummary(name: str, value: TfExpressionEx, passthru: TfExpressionEx = None, condition: TfExpressionEx = True) -> TfExpressionEx:
+    """Create a new autosummary.
+
+    Args:
+        name:     Name to use in TensorBoard
+        value:    TensorFlow expression or python value to track
+        passthru: Optionally return this TF node without modifications but tack an autosummary update side-effect to this node.
+
+    Example use of the passthru mechanism:
+
+    n = autosummary('l2loss', loss, passthru=n)
+
+    This is a shorthand for the following code:
+
+    with tf.control_dependencies([autosummary('l2loss', loss)]):
+        n = tf.identity(n)
+    """
+    tfutil.assert_tf_initialized()
+    name_id = name.replace("/", "_")
+
+    if tfutil.is_tf_expression(value):
+        with tf.name_scope("summary_" + name_id), tf.device(value.device):
+            condition = tf.convert_to_tensor(condition, name='condition')
+            update_op = tf.cond(condition, lambda: tf.group(_create_var(name, value)), tf.no_op)
+            with tf.control_dependencies([update_op]):
+                return tf.identity(value if passthru is None else passthru)
+
+    else:  # python scalar or numpy array
+        assert not tfutil.is_tf_expression(passthru)
+        assert not tfutil.is_tf_expression(condition)
+        if condition:
+            if name not in _immediate:
+                with tfutil.absolute_name_scope("Autosummary/" + name_id), tf.device(None), tf.control_dependencies(None):
+                    update_value = tf.placeholder(_dtype)
+                    update_op = _create_var(name, update_value)
+                    _immediate[name] = update_op, update_value
+            update_op, update_value = _immediate[name]
+            tfutil.run(update_op, {update_value: value})
+        return value if passthru is None else passthru
+
+
+def finalize_autosummaries() -> None:
+    """Create the necessary ops to include autosummaries in TensorBoard report.
+    Note: This should be done only once per graph.
+    """
+    global _finalized
+    tfutil.assert_tf_initialized()
+
+    if _finalized:
+        return None
+
+    _finalized = True
+    tfutil.init_uninitialized_vars([var for vars_list in _vars.values() for var in vars_list])
+
+    # Create summary ops.
+    with tf.device(None), tf.control_dependencies(None):
+        for name, vars_list in _vars.items():
+            name_id = name.replace("/", "_")
+            with tfutil.absolute_name_scope("Autosummary/" + name_id):
+                moments = tf.add_n(vars_list)
+                moments /= moments[0]
+                with tf.control_dependencies([moments]):  # read before resetting
+                    reset_ops = [tf.assign(var, tf.zeros(3, dtype=_dtype)) for var in vars_list]
+                    with tf.name_scope(None), tf.control_dependencies(reset_ops):  # reset before reporting
+                        mean = moments[1]
+                        std = tf.sqrt(moments[2] - tf.square(moments[1]))
+                        tf.summary.scalar(name, mean)
+                        if enable_custom_scalars:
+                            tf.summary.scalar("xCustomScalars/" + name + "/margin_lo", mean - std)
+                            tf.summary.scalar("xCustomScalars/" + name + "/margin_hi", mean + std)
+
+    # Setup layout for custom scalars.
+    layout = None
+    if enable_custom_scalars:
+        cat_dict = OrderedDict()
+        for series_name in sorted(_vars.keys()):
+            p = series_name.split("/")
+            cat = p[0] if len(p) >= 2 else ""
+            chart = "/".join(p[1:-1]) if len(p) >= 3 else p[-1]
+            if cat not in cat_dict:
+                cat_dict[cat] = OrderedDict()
+            if chart not in cat_dict[cat]:
+                cat_dict[cat][chart] = []
+            cat_dict[cat][chart].append(series_name)
+        categories = []
+        for cat_name, chart_dict in cat_dict.items():
+            charts = []
+            for chart_name, series_names in chart_dict.items():
+                series = []
+                for series_name in series_names:
+                    series.append(layout_pb2.MarginChartContent.Series(
+                        value=series_name,
+                        lower="xCustomScalars/" + series_name + "/margin_lo",
+                        upper="xCustomScalars/" + series_name + "/margin_hi"))
+                margin = layout_pb2.MarginChartContent(series=series)
+                charts.append(layout_pb2.Chart(title=chart_name, margin=margin))
+            categories.append(layout_pb2.Category(title=cat_name, chart=charts))
+        layout = summary_lib.custom_scalar_pb(layout_pb2.Layout(category=categories))
+    return layout
+
+def save_summaries(file_writer, global_step=None):
+    """Call FileWriter.add_summary() with all summaries in the default graph,
+    automatically finalizing and merging them on the first call.
+    """
+    global _merge_op
+    tfutil.assert_tf_initialized()
+
+    if _merge_op is None:
+        layout = finalize_autosummaries()
+        if layout is not None:
+            file_writer.add_summary(layout)
+        with tf.device(None), tf.control_dependencies(None):
+            _merge_op = tf.summary.merge_all()
+
+    file_writer.add_summary(_merge_op.eval(), global_step)

stylegan_human/dnnlib/tflib/custom_ops.py

+# Copyright (c) SenseTime Research. All rights reserved.
+
+# Copyright (c) 2019, NVIDIA Corporation. All rights reserved.
+#
+# This work is made available under the Nvidia Source Code License-NC.
+# To view a copy of this license, visit
+# https://nvlabs.github.io/stylegan2/license.html
+
+"""TensorFlow custom ops builder.
+"""
+
+import os
+import re
+import uuid
+import hashlib
+import tempfile
+import shutil
+import tensorflow as tf
+from tensorflow.python.client import device_lib # pylint: disable=no-name-in-module
+
+#----------------------------------------------------------------------------
+# Global options.
+
+cuda_cache_path = os.path.join(os.path.dirname(__file__), '_cudacache')
+cuda_cache_version_tag = 'v1'
+do_not_hash_included_headers = False # Speed up compilation by assuming that headers included by the CUDA code never change. Unsafe!
+verbose = True # Print status messages to stdout.
+
+compiler_bindir_search_path = [
+    'C:/Program Files (x86)/Microsoft Visual Studio/2017/Community/VC/Tools/MSVC/14.14.26428/bin/Hostx64/x64',
+    'C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.23.28105/bin/Hostx64/x64',
+    'C:/Program Files (x86)/Microsoft Visual Studio 14.0/vc/bin',
+]
+
+#----------------------------------------------------------------------------
+# Internal helper funcs.
+
+def _find_compiler_bindir():
+    for compiler_path in compiler_bindir_search_path:
+        if os.path.isdir(compiler_path):
+            return compiler_path
+    return None
+
+def _get_compute_cap(device):
+    caps_str = device.physical_device_desc
+    m = re.search('compute capability: (\\d+).(\\d+)', caps_str)
+    major = m.group(1)
+    minor = m.group(2)
+    return (major, minor)
+
+def _get_cuda_gpu_arch_string():
+    gpus = [x for x in device_lib.list_local_devices() if x.device_type == 'GPU']
+    if len(gpus) == 0:
+        raise RuntimeError('No GPU devices found')
+    (major, minor) = _get_compute_cap(gpus[0])
+    return 'sm_%s%s' % (major, minor)
+
+def _run_cmd(cmd):
+    with os.popen(cmd) as pipe:
+        output = pipe.read()
+        status = pipe.close()
+    if status is not None:
+        raise RuntimeError('NVCC returned an error. See below for full command line and output log:\n\n%s\n\n%s' % (cmd, output))
+
+def _prepare_nvcc_cli(opts):
+    cmd = 'nvcc ' + opts.strip()
+    cmd += ' --disable-warnings'
+    cmd += ' --include-path "%s"' % tf.sysconfig.get_include()
+    cmd += ' --include-path "%s"' % os.path.join(tf.sysconfig.get_include(), 'external', 'protobuf_archive', 'src')
+    cmd += ' --include-path "%s"' % os.path.join(tf.sysconfig.get_include(), 'external', 'com_google_absl')
+    cmd += ' --include-path "%s"' % os.path.join(tf.sysconfig.get_include(), 'external', 'eigen_archive')
+
+    compiler_bindir = _find_compiler_bindir()
+    if compiler_bindir is None:
+        # Require that _find_compiler_bindir succeeds on Windows.  Allow
+        # nvcc to use whatever is the default on Linux.
+        if os.name == 'nt':
+            raise RuntimeError('Could not find MSVC/GCC/CLANG installation on this computer. Check compiler_bindir_search_path list in "%s".' % __file__)
+    else:
+        cmd += ' --compiler-bindir "%s"' % compiler_bindir
+    cmd += ' 2>&1'
+    return cmd
+
+#----------------------------------------------------------------------------
+# Main entry point.
+
+_plugin_cache = dict()
+
+def get_plugin(cuda_file):
+    cuda_file_base = os.path.basename(cuda_file)
+    cuda_file_name, cuda_file_ext = os.path.splitext(cuda_file_base)
+
+    # Already in cache?
+    if cuda_file in _plugin_cache:
+        return _plugin_cache[cuda_file]
+
+    # Setup plugin.
+    if verbose:
+        print('Setting up TensorFlow plugin "%s": ' % cuda_file_base, end='', flush=True)
+    try:
+        # Hash CUDA source.
+        md5 = hashlib.md5()
+        with open(cuda_file, 'rb') as f:
+            md5.update(f.read())
+        md5.update(b'\n')
+
+        # Hash headers included by the CUDA code by running it through the preprocessor.
+        if not do_not_hash_included_headers:
+            if verbose:
+                print('Preprocessing... ', end='', flush=True)
+            with tempfile.TemporaryDirectory() as tmp_dir:
+                tmp_file = os.path.join(tmp_dir, cuda_file_name + '_tmp' + cuda_file_ext)
+                _run_cmd(_prepare_nvcc_cli('"%s" --preprocess -o "%s" --keep --keep-dir "%s"' % (cuda_file, tmp_file, tmp_dir)))
+                with open(tmp_file, 'rb') as f:
+                    bad_file_str = ('"' + cuda_file.replace('\\', '/') + '"').encode('utf-8') # __FILE__ in error check macros
+                    good_file_str = ('"' + cuda_file_base + '"').encode('utf-8')
+                    for ln in f:
+                        if not ln.startswith(b'# ') and not ln.startswith(b'#line '): # ignore line number pragmas
+                            ln = ln.replace(bad_file_str, good_file_str)
+                            md5.update(ln)
+                    md5.update(b'\n')
+
+        # Select compiler options.
+        compile_opts = ''
+        if os.name == 'nt':
+            compile_opts += '"%s"' % os.path.join(tf.sysconfig.get_lib(), 'python', '_pywrap_tensorflow_internal.lib')
+        elif os.name == 'posix':
+            compile_opts += '"%s"' % os.path.join(tf.sysconfig.get_lib(), 'python', '_pywrap_tensorflow_internal.so')
+            compile_opts += ' --compiler-options \'-fPIC -D_GLIBCXX_USE_CXX11_ABI=0\''
+        else:
+            assert False # not Windows or Linux, w00t?
+        compile_opts += ' --gpu-architecture=%s' % _get_cuda_gpu_arch_string()
+        compile_opts += ' --use_fast_math'
+        nvcc_cmd = _prepare_nvcc_cli(compile_opts)
+
+        # Hash build configuration.
+        md5.update(('nvcc_cmd: ' + nvcc_cmd).encode('utf-8') + b'\n')
+        md5.update(('tf.VERSION: ' + tf.VERSION).encode('utf-8') + b'\n')
+        md5.update(('cuda_cache_version_tag: ' + cuda_cache_version_tag).encode('utf-8') + b'\n')
+
+        # Compile if not already compiled.
+        bin_file_ext = '.dll' if os.name == 'nt' else '.so'
+        bin_file = os.path.join(cuda_cache_path, cuda_file_name + '_' + md5.hexdigest() + bin_file_ext)
+        if not os.path.isfile(bin_file):
+            if verbose:
+                print('Compiling... ', end='', flush=True)
+            with tempfile.TemporaryDirectory() as tmp_dir:
+                tmp_file = os.path.join(tmp_dir, cuda_file_name + '_tmp' + bin_file_ext)
+                _run_cmd(nvcc_cmd + ' "%s" --shared -o "%s" --keep --keep-dir "%s"' % (cuda_file, tmp_file, tmp_dir))
+                os.makedirs(cuda_cache_path, exist_ok=True)
+                intermediate_file = os.path.join(cuda_cache_path, cuda_file_name + '_' + uuid.uuid4().hex + '_tmp' + bin_file_ext)
+                shutil.copyfile(tmp_file, intermediate_file)
+                os.rename(intermediate_file, bin_file) # atomic
+
+        # Load.
+        if verbose:
+            print('Loading... ', end='', flush=True)
+        plugin = tf.load_op_library(bin_file)
+
+        # Add to cache.
+        _plugin_cache[cuda_file] = plugin
+        if verbose:
+            print('Done.', flush=True)
+        return plugin
+
+    except:
+        if verbose:
+            print('Failed!', flush=True)
+        raise
+
+#----------------------------------------------------------------------------

stylegan_human/dnnlib/tflib/ops/__init__.py

+# Copyright (c) SenseTime Research. All rights reserved.
+
+# Copyright (c) 2019, NVIDIA Corporation. All rights reserved.
+#
+# This work is made available under the Nvidia Source Code License-NC.
+# To view a copy of this license, visit
+# https://nvlabs.github.io/stylegan2/license.html
+
+# empty

stylegan_human/dnnlib/tflib/ops/fused_bias_act.cu

+// Copyright (c) SenseTime Research. All rights reserved.
+
+// Copyright (c) 2019, NVIDIA Corporation. All rights reserved.
+//
+// This work is made available under the Nvidia Source Code License-NC.
+// To view a copy of this license, visit
+// https://nvlabs.github.io/stylegan2/license.html
+
+#define EIGEN_USE_GPU
+#define __CUDA_INCLUDE_COMPILER_INTERNAL_HEADERS__
+#include "tensorflow/core/framework/op.h"
+#include "tensorflow/core/framework/op_kernel.h"
+#include "tensorflow/core/framework/shape_inference.h"
+#include <stdio.h>
+
+using namespace tensorflow;
+using namespace tensorflow::shape_inference;
+
+#define OP_CHECK_CUDA_ERROR(CTX, CUDA_CALL) do { cudaError_t err = CUDA_CALL; OP_REQUIRES(CTX, err == cudaSuccess, errors::Internal(cudaGetErrorName(err))); } while (false)
+
+//------------------------------------------------------------------------
+// CUDA kernel.
+
+template <class T>
+struct FusedBiasActKernelParams
+{
+    const T*    x;      // [sizeX]
+    const T*    b;      // [sizeB] or NULL
+    const T*    ref;    // [sizeX] or NULL
+    T*          y;      // [sizeX]
+
+    int         grad;
+    int         axis;
+    int         act;
+    float       alpha;
+    float       gain;
+
+    int         sizeX;
+    int         sizeB;
+    int         stepB;
+    int         loopX;
+};
+
+template <class T>
+static __global__ void FusedBiasActKernel(const FusedBiasActKernelParams<T> p)
+{
+    const float expRange        = 80.0f;
+    const float halfExpRange    = 40.0f;
+    const float seluScale       = 1.0507009873554804934193349852946f;
+    const float seluAlpha       = 1.6732632423543772848170429916717f;
+
+    // Loop over elements.
+    int xi = blockIdx.x * p.loopX * blockDim.x + threadIdx.x;
+    for (int loopIdx = 0; loopIdx < p.loopX && xi < p.sizeX; loopIdx++, xi += blockDim.x)
+    {
+        // Load and apply bias.
+        float x = (float)p.x[xi];
+        if (p.b)
+            x += (float)p.b[(xi / p.stepB) % p.sizeB];
+        float ref = (p.ref) ? (float)p.ref[xi] : 0.0f;
+        if (p.gain != 0.0f & p.act != 9)
+            ref /= p.gain;
+
+        // Evaluate activation func.
+        float y;
+        switch (p.act * 10 + p.grad)
+        {
+            // linear
+            default:
+            case 10: y = x; break;
+            case 11: y = x; break;
+            case 12: y = 0.0f; break;
+
+            // relu
+            case 20: y = (x > 0.0f) ? x : 0.0f; break;
+            case 21: y = (ref > 0.0f) ? x : 0.0f; break;
+            case 22: y = 0.0f; break;
+
+            // lrelu
+            case 30: y = (x > 0.0f) ? x : x * p.alpha; break;
+            case 31: y = (ref > 0.0f) ? x : x * p.alpha; break;
+            case 32: y = 0.0f; break;
+
+            // tanh
+            case 40: { float c = expf(x); float d = 1.0f / c; y = (x < -expRange) ? -1.0f : (x > expRange) ? 1.0f : (c - d) / (c + d); } break;
+            case 41: y = x * (1.0f - ref * ref); break;
+            case 42: y = x * (1.0f - ref * ref) * (-2.0f * ref); break;
+
+            // sigmoid
+            case 50: y = (x < -expRange) ? 0.0f : 1.0f / (expf(-x) + 1.0f); break;
+            case 51: y = x * ref * (1.0f - ref); break;
+            case 52: y = x * ref * (1.0f - ref) * (1.0f - 2.0f * ref); break;
+
+            // elu
+            case 60: y = (x >= 0.0f) ? x : expf(x) - 1.0f; break;
+            case 61: y = (ref >= 0.0f) ? x : x * (ref + 1.0f); break;
+            case 62: y = (ref >= 0.0f) ? 0.0f : x * (ref + 1.0f); break;
+
+            // selu
+            case 70: y = (x >= 0.0f) ? seluScale * x : (seluScale * seluAlpha) * (expf(x) - 1.0f); break;
+            case 71: y = (ref >= 0.0f) ? x * seluScale : x * (ref + seluScale * seluAlpha); break;
+            case 72: y = (ref >= 0.0f) ? 0.0f : x * (ref + seluScale * seluAlpha); break;
+
+            // softplus
+            case 80: y = (x > expRange) ? x : logf(expf(x) + 1.0f); break;
+            case 81: y = x * (1.0f - expf(-ref)); break;
+            case 82: { float c = expf(-ref); y = x * c * (1.0f - c); } break;
+
+            // swish
+            case 90: y = (x < -expRange) ? 0.0f : x / (expf(-x) + 1.0f); break;
+            case 91: { float c = expf(ref); float d = c + 1.0f; y = (ref > halfExpRange) ? x : x * c * (ref + d) / (d * d); } break;
+            case 92: { float c = expf(ref); float d = c + 1.0f; y = (ref > halfExpRange) ? 0.0f : x * c * (ref * (2.0f - d) + 2.0f * d) / (d * d * d); } break;
+        }
+
+        // Apply gain and store.
+        p.y[xi] = (T)(y * p.gain);
+    }
+}
+
+//------------------------------------------------------------------------
+// TensorFlow op.
+
+template <class T>
+struct FusedBiasActOp : public OpKernel
+{
+    FusedBiasActKernelParams<T> m_attribs;
+
+    FusedBiasActOp(OpKernelConstruction* ctx) : OpKernel(ctx)
+    {
+        memset(&m_attribs, 0, sizeof(m_attribs));
+        OP_REQUIRES_OK(ctx, ctx->GetAttr("grad", &m_attribs.grad));
+        OP_REQUIRES_OK(ctx, ctx->GetAttr("axis", &m_attribs.axis));
+        OP_REQUIRES_OK(ctx, ctx->GetAttr("act", &m_attribs.act));
+        OP_REQUIRES_OK(ctx, ctx->GetAttr("alpha", &m_attribs.alpha));
+        OP_REQUIRES_OK(ctx, ctx->GetAttr("gain", &m_attribs.gain));
+        OP_REQUIRES(ctx, m_attribs.grad >= 0, errors::InvalidArgument("grad must be non-negative"));
+        OP_REQUIRES(ctx, m_attribs.axis >= 0, errors::InvalidArgument("axis must be non-negative"));
+        OP_REQUIRES(ctx, m_attribs.act >= 0, errors::InvalidArgument("act must be non-negative"));
+    }
+
+    void Compute(OpKernelContext* ctx)
+    {
+        FusedBiasActKernelParams<T> p = m_attribs;
+        cudaStream_t stream = ctx->eigen_device<Eigen::GpuDevice>().stream();
+
+        const Tensor& x     = ctx->input(0); // [...]
+        const Tensor& b     = ctx->input(1); // [sizeB] or [0]
+        const Tensor& ref   = ctx->input(2); // x.shape or [0]
+        p.x = x.flat<T>().data();
+        p.b = (b.NumElements()) ? b.flat<T>().data() : NULL;
+        p.ref = (ref.NumElements()) ? ref.flat<T>().data() : NULL;
+        OP_REQUIRES(ctx, b.NumElements() == 0 || m_attribs.axis < x.dims(), errors::InvalidArgument("axis out of bounds"));
+        OP_REQUIRES(ctx, b.dims() == 1, errors::InvalidArgument("b must have rank 1"));
+        OP_REQUIRES(ctx, b.NumElements() == 0 || b.NumElements() == x.dim_size(m_attribs.axis), errors::InvalidArgument("b has wrong number of elements"));
+        OP_REQUIRES(ctx, ref.NumElements() == ((p.grad == 0) ? 0 : x.NumElements()), errors::InvalidArgument("ref has wrong number of elements"));
+        OP_REQUIRES(ctx, x.NumElements() <= kint32max, errors::InvalidArgument("x is too large"));
+
+        p.sizeX = (int)x.NumElements();
+        p.sizeB = (int)b.NumElements();
+        p.stepB = 1;
+        for (int i = m_attribs.axis + 1; i < x.dims(); i++)
+            p.stepB *= (int)x.dim_size(i);
+
+        Tensor* y = NULL; // x.shape
+        OP_REQUIRES_OK(ctx, ctx->allocate_output(0, x.shape(), &y));
+        p.y = y->flat<T>().data();
+
+        p.loopX = 4;
+        int blockSize = 4 * 32;
+        int gridSize = (p.sizeX - 1) / (p.loopX * blockSize) + 1;
+        void* args[] = {&p};
+        OP_CHECK_CUDA_ERROR(ctx, cudaLaunchKernel((void*)FusedBiasActKernel<T>, gridSize, blockSize, args, 0, stream));
+    }
+};
+
+REGISTER_OP("FusedBiasAct")
+    .Input      ("x: T")
+    .Input      ("b: T")
+    .Input      ("ref: T")
+    .Output     ("y: T")
+    .Attr       ("T: {float, half}")
+    .Attr       ("grad: int = 0")
+    .Attr       ("axis: int = 1")
+    .Attr       ("act: int = 0")
+    .Attr       ("alpha: float = 0.0")
+    .Attr       ("gain: float = 1.0");
+REGISTER_KERNEL_BUILDER(Name("FusedBiasAct").Device(DEVICE_GPU).TypeConstraint<float>("T"), FusedBiasActOp<float>);
+REGISTER_KERNEL_BUILDER(Name("FusedBiasAct").Device(DEVICE_GPU).TypeConstraint<Eigen::half>("T"), FusedBiasActOp<Eigen::half>);
+
+//------------------------------------------------------------------------

stylegan_human/docs/Dataset.md

+# SHHQ Dataset
+<img src="../img/preview_samples1.png" width="96%" height="96%">
+
+## Overview
+SHHQ is a dataset with high-quality full-body human images in a resolution of 1024 × 512.
+Since we need to follow a rigorous legal review in our institute, we can not release all of the data at once.
+
+For now, SHHQ-1.0 with 40K images is released! More data will be released in the later versions.
+
+
+## Data Sources
+Images are collected in two main ways: 
+1) From the Internet. 
+We developed a crawler tool with an official API, mainly downloading images from Flickr, Pixabay and Pexels. So you need to meet all the following licenses when using the dataset: CC0, [Pixabay License](https://pixabay.com/service/license/), and [Pexels Licenses](https://www.pexels.com/license/).
+2) From the data providers. 
+We purchased images from databases of individual photographers, modeling agencies and other suppliers.
+Images were reviewed by our legal team prior to purchase to ensure permission for use in research.
+
+### Note: 
+The composition of SHHQ-1.0: 
+
+1) Images obtained from the above sources.
+2) Processed 9991 DeepFashion [[1]](#1) images (retain only full body images).
+3) 1940 African images from the InFashAI [[2]](#2) dataset to increase data diversity.
+
+## Data License
+We are aware of privacy concerns and seriously treat the license and privacy issues. All released data will be ensured under the license of CC0 and free for research use. Also, persons in the dataset are anonymised without additional private or sensitive metadata.
+
+## Agreement
+The SHHQ is available for non-commercial research purposes only. 
+
+You agree not to reproduce, duplicate, copy, sell, trade, resell or exploit any portion of the images and any portion of the derived data for commercial purposes. 
+
+You agree NOT to further copy, publish or distribute any portion of SHHQ to any third party for any purpose. Except, for internal use at a single site within the same organization it is allowed to make copies of the dataset.
+
+Shanghai AI Lab reserves the right to terminate your access to the SHHQ at any time.
+
+## Dataset Preview
+For those interested in our dataset, we provide a preview version with 100 images randomly sampled from SHHQ-1.0: [SHHQ-1.0_samples](https://drive.google.com/file/d/1tnNFfmFtzRbYL3qEnNXQ_ShaN9YV5tI5/view?usp=sharing).
+
+In SHHQ-1.0, we provide aligned raw images along with machine-calculated segmentation masks. Later we are planning to release manually annotated human-parsing version of these 40,000 images. Please stay tuned. 
+ 
+> We also provide script [bg_white.py](../bg_white.py) to whiten the background of the raw image using its segmentation mask.
+
+If you want to access the full SHHQ-1.0, please read the following instructions.
+
+## Model trained using SHHQ-1.0
+
+| Structure | 1024x512 | Metric | Scores |  512x256 | Metric | Scores | 
+| --------- |:----------:| :----------:| :----------:|  :-----: |  :-----: |  :-----: | 
+| StyleGAN1 | to be released | - | - | to be released | - | - |
+| StyleGAN2 | [SHHQ-1.0_sg2_1024.pkl](https://drive.google.com/file/d/1PuvE72xpc69Zq4y58dohuKbG9dFnnjEX/view?usp=sharing) | fid50k_full | 3.56 | [SHHQ-1.0_sg2_512.pkl](https://drive.google.com/file/d/170t2FRWxR8_TG3_y0nVtDBogLPOClnyf/view?usp=sharing) | fid50k_full | 3.68 |
+| StyleGAN3 | to be released | - | - |to be released | - | - |
+
+
+## Download Instructions
+Please download the SHHQ Dataset Release Agreement from [link](./SHHQ_Dataset_Release_Agreement.pdf).
+Read it carefully, complete and sign it appropriately. 
+
+Please send the completed form to Jianglin Fu (arlenefu@outlook.com) and Shikai Li (lishikai@pjlab.org.cn), and cc to Wayne Wu (wuwenyan0503@gmail.com) using institutional email address. The email Subject Title is "SHHQ Dataset Release Agreement". We will verify your request and contact you with the dataset link and password to unzip the image data.
+
+Note:
+
+1. We are currently facing large incoming applications, and we need to carefully verify all the applicants, please be patient, and we will reply to you as soon as possible.
+
+2. The signature in the agreement should be hand-written.
+
+## References
+<a id="1">[1]</a> 
+Liu, Ziwei and Luo, Ping and Qiu, Shi and Wang, Xiaogang and Tang, Xiaoou. DeepFashion: Powering Robust Clothes Recognition and Retrieval with Rich Annotations. CVPR (2016)
+
+<a id="2">[2]</a> 
+Hacheme, Gilles and Sayouti, Noureini. Neural fashion image captioning: Accounting for data diversity. arXiv preprint arXiv:2106.12154 (2021)
+