diff --git a/.DS_Store b/.DS_Store index e955512..4e39217 100644 Binary files a/.DS_Store and b/.DS_Store differ diff --git a/README.md b/README.md index 37c4684..031b496 100644 --- a/README.md +++ b/README.md @@ -17,7 +17,178 @@ Official implementation of DCT-Net for Full-body Portrait Stylization. ## Demo -![demo_vid](assets/demo.gif) +![demo](assets/demo.gif) + + +## News + +(2023-03-14) The training guidance has been released, train DCT-Net with your own style data. + +(2023-02-20) Two new style pre-trained models (design, illustration) trained with combined DCT-Net and Stable-Diffusion are provided. The training guidance will be released soon. + +(2022-10-09) The multi-style pre-trained models (3d, handdrawn, sketch, artstyle) and usage are available now. + +(2022-08-08) The pertained model and infer code of 'anime' style is available now. More styles coming soon. + +(2022-08-08) cartoon function can be directly call from pythonSDK. + +(2022-07-07) The paper is available now at arxiv(https://arxiv.org/abs/2207.02426). + + +## Web Demo +- Integrated into [Colab notebook](https://colab.research.google.com/github/menyifang/DCT-Net/blob/main/notebooks/inference.ipynb). Try out the colab demo.google colab logo + +- Integrated into [Huggingface Spaces 🤗](https://huggingface.co/spaces) using [Gradio](https://github.com/gradio-app/gradio). Try out the Web Demo [![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/SIGGRAPH2022/DCT-Net) + +- [Chinese version] Integrated into [ModelScope](https://modelscope.cn/#/models). Try out the Web Demo [![ModelScope Spaces]( +https://img.shields.io/badge/ModelScope-Spaces-blue)](https://modelscope.cn/#/models/damo/cv_unet_person-image-cartoon_compound-models/summary) + +## Requirements +* python 3 +* tensorflow (>=1.14, training only support tf1.x) +* easydict +* numpy +* both CPU/GPU are supported + + +## Quick Start +google colab logo + + +```bash +git clone https://github.com/menyifang/DCT-Net.git +cd DCT-Net + +``` + +### Installation +```bash +conda create -n dctnet python=3.7 +conda activate dctnet +pip install --upgrade tensorflow-gpu==1.15 # GPU support, use tensorflow for CPU only +pip install "modelscope[cv]==1.3.2" -f https://modelscope.oss-cn-beijing.aliyuncs.com/releases/repo.html +pip install "modelscope[multi-modal]==1.3.2" -f https://modelscope.oss-cn-beijing.aliyuncs.com/releases/repo.html +``` + +### Downloads + +| [](https://modelscope.cn/models/damo/cv_unet_person-image-cartoon_compound-models/summary) | [](https://modelscope.cn/models/damo/cv_unet_person-image-cartoon-3d_compound-models/summary) | [](https://modelscope.cn/models/damo/cv_unet_person-image-cartoon-handdrawn_compound-models/summary)| [](https://modelscope.cn/models/damo/cv_unet_person-image-cartoon-sketch_compound-models/summary)| [](https://modelscope.cn/models/damo/cv_unet_person-image-cartoon-artstyle_compound-models/summary)| +|:--:|:--:|:--:|:--:|:--:| +| [anime](https://modelscope.cn/models/damo/cv_unet_person-image-cartoon_compound-models/summary) | [3d](https://modelscope.cn/models/damo/cv_unet_person-image-cartoon-3d_compound-models/summary) | [handdrawn](https://modelscope.cn/models/damo/cv_unet_person-image-cartoon-handdrawn_compound-models/summary) | [sketch](https://modelscope.cn/models/damo/cv_unet_person-image-cartoon-sketch_compound-models/summary) | [artstyle](https://modelscope.cn/models/damo/cv_unet_person-image-cartoon-artstyle_compound-models/summary) | + +| [](https://modelscope.cn/models/damo/cv_unet_person-image-cartoon-sd-design_compound-models/summary) | [](https://modelscope.cn/models/damo/cv_unet_person-image-cartoon-sd-illustration_compound-models/summary) | +|:--:|:--:| +| [design](https://modelscope.cn/models/damo/cv_unet_person-image-cartoon-sd-design_compound-models/summary) | [illustration](https://modelscope.cn/models/damo/cv_unet_person-image-cartoon-sd-illustration_compound-models/summary) + +Pre-trained models in different styles can be downloaded by +```bash +python download.py +``` + +### Inference + +- from python SDK +```bash +python run_sdk.py +``` + +- from source code +```bash +python run.py +``` + +### Video cartoonization + +![demo_vid](assets/video.gif) + +video can be directly processed as image sequences, style choice [option: anime, 3d, handdrawn, sketch, artstyle, sd-design, sd-illustration] + +```bash +python run_vid.py --style anime +``` + + +## Training + +### Data preparation +``` +face_photo: face dataset such as [FFHQ](https://github.com/NVlabs/ffhq-dataset) or other collected real faces. +face_cartoon: 100-300 cartoon face images in a specific style, which can be self-collected or synthsized with generative models. +``` +Due to the copyrighe issues, we can not provide collected cartoon exemplar for training. You can produce cartoon exemplars with the style-finetuned Stable-Diffusion (SD) models, which can be downloaded from modelscope or huggingface hubs. + +The effects of some style-finetune SD models are as follows: + +| [](https://modelscope.cn/models/damo/cv_cartoon_stable_diffusion_design/summary) | [](https://modelscope.cn/models/damo/cv_cartoon_stable_diffusion_watercolor) | [](https://modelscope.cn/models/damo/cv_cartoon_stable_diffusion_illustration/summary)| [](https://modelscope.cn/models/damo/cv_cartoon_stable_diffusion_clipart/summary)| [](https://modelscope.cn/models/damo/cv_cartoon_stable_diffusion_flat/summary)| +|:--:|:--:|:--:|:--:|:--:| +| [design](https://modelscope.cn/models/damo/cv_cartoon_stable_diffusion_design/summary) | [watercolor](https://modelscope.cn/models/damo/cv_cartoon_stable_diffusion_watercolor/summary) | [illustration](https://modelscope.cn/models/damo/cv_cartoon_stable_diffusion_illustration/summary) | [clipart](https://modelscope.cn/models/damo/cv_cartoon_stable_diffusion_clipart/summary) | [flat](https://modelscope.cn/models/damo/cv_cartoon_stable_diffusion_flat/summary) | + +- Generate stylized data, style choice [option: clipart, design, illustration, watercolor, flat] +```bash +python generate_data.py --style clipart +``` + +- preprocess + +extract aligned faces from raw style images: +```bash +python extract_align_faces.py --src_dir 'data/raw_style_data' +``` + +- train content calibration network + +install environment required by (stylegan2-pytorch)[https://github.com/rosinality/stylegan2-pytorch] +```bash +cd source/stylegan2 +python prepare_data.py '../../data/face_cartoon' --size 256 --out '../../data/stylegan2/traindata' +CUDA_VISIBLE_DEVICES=0 python train_condition.py --name 'ffhq_style_s256' --path '../../data/stylegan2/traindata' --config config/conf_server_train_condition_shell.json +``` + +after training, generated content calibrated samples via: +```bash +python style_blend.py --name 'ffhq_style_s256' +python generate_blendmodel.py --name 'ffhq_style_s256' --save_dir '../../data/face_cartoon/syn_style_faces' +``` + +- geometry calibration + +run geometry calibration for both photo and cartoon: +```bash +cd source +python image_flip_agument_parallel.py --data_dir '../data/face_cartoon' +python image_scale_agument_parallel_flat.py --data_dir '../data/face_cartoon' +python image_rotation_agument_parallel_flat.py --data_dir '../data/face_cartoon' +``` + +- train texture translator + +The dataset structure is recommended as: +``` ++—data +| +—face_photo +| +—face_cartoon +``` + +resume training from the pretrai# DCT-Net: Domain-Calibrated Translation for Portrait Stylization + +### [Project page](https://menyifang.github.io/projects/DCTNet/DCTNet.html) | [Video](https://www.youtube.com/watch?v=Y8BrfOjXYQM) | [Paper](https://arxiv.org/abs/2207.02426) + +Official implementation of DCT-Net for Full-body Portrait Stylization. + + +> [**DCT-Net: Domain-Calibrated Translation for Portrait Stylization**](arxiv_url_coming_soon), +> [Yifang Men](https://menyifang.github.io/)1, Yuan Yao1, Miaomiao Cui1, [Zhouhui Lian](https://www.icst.pku.edu.cn/zlian/)2, Xuansong Xie1, +> _1[DAMO Academy, Alibaba Group](https://damo.alibaba.com), Beijing, China_ +> _2[Wangxuan Institute of Computer Technology, Peking University](https://www.icst.pku.edu.cn/), China_ +> In: SIGGRAPH 2022 (**TOG**) +> *[arXiv preprint](https://arxiv.org/abs/2207.02426)* + +google colab logo +[![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/SIGGRAPH2022/DCT-Net) + + +## Demo +![demo](assets/demo.gif) ## News @@ -44,7 +215,6 @@ https://img.shields.io/badge/ModelScope-Spaces-blue)](https://modelscope.cn/#/mo * python 3 * tensorflow (>=1.14) * easydict -* imageio[ffmpeg] * numpy * both CPU/GPU are supported @@ -63,9 +233,11 @@ cd DCT-Net ```bash conda create -n dctnet python=3.7 conda activate dctnet +pip install numpy==1.18.5 +pip install torch==1.7.1+cu101 torchvision==0.8.2+cu101 torchaudio==0.7.2 -f https://download.pytorch.org/whl/torch_stable.html pip install --upgrade tensorflow-gpu==1.15 # GPU support, use tensorflow for CPU only -pip install "modelscope[cv]==1.3.0" -f https://modelscope.oss-cn-beijing.aliyuncs.com/releases/repo.html -pip install "modelscope[multi-modal]==1.3.0" -f https://modelscope.oss-cn-beijing.aliyuncs.com/releases/repo.html +pip install "modelscope[cv]==1.3.2" -f https://modelscope.oss-cn-beijing.aliyuncs.com/releases/repo.html +pip install "modelscope[multi-modal]==1.3.2" -f https://modelscope.oss-cn-beijing.aliyuncs.com/releases/repo.html ``` ### Downloads @@ -102,11 +274,12 @@ python run.py video can be directly processed as image sequences, style choice [option: anime, 3d, handdrawn, sketch, artstyle, sd-design, sd-illustration] ```bash -python run_vid.py --video_path input.mp4 --save_path res.mp4 --style anime +python run_vid.py --style anime ``` ## Training +google colab logo ### Data preparation ``` @@ -126,16 +299,54 @@ The effects of some style-finetune SD models are as follows: python generate_data.py --style clipart ``` +- preprocess -### Train content calibration network -To-be-added +extract aligned faces from raw style images: +```bash +python extract_align_faces.py --src_dir 'data/raw_style_data' +``` -### Geometry calibration -To-be-added +- train content calibration network -### Train texture translator -To-be-added +install environment required by (stylegan2-pytorch)[https://github.com/rosinality/stylegan2-pytorch] +```bash +cd source/stylegan2 +python prepare_data.py '../../data/face_cartoon' --size 256 --out '../../data/stylegan2/traindata' +CUDA_VISIBLE_DEVICES=0 python train_condition.py --name 'ffhq_style_s256' --path '../../data/stylegan2/traindata' --config config/conf_server_train_condition_shell.json +``` + +after training, generated content calibrated samples via: +```bash +python style_blend.py --name 'ffhq_style_s256' +python generate_blendmodel.py --name 'ffhq_style_s256' --save_dir '../../data/face_cartoon/syn_style_faces' +``` + +- geometry calibration + +run geometry calibration for both photo and cartoon: +```bash +cd source +python image_flip_agument_parallel.py --data_dir '../data/face_cartoon' +python image_scale_agument_parallel_flat.py --data_dir '../data/face_cartoon' +python image_rotation_agument_parallel_flat.py --data_dir '../data/face_cartoon' +``` + +- train texture translator + +The dataset structure is recommended as: +``` ++—data +| +—face_photo +| +—face_cartoon +``` + +resume training from pretrained model in similar style: +style can be chosen from 'anime, 3d, handdrawn, sketch, artstyle, sd-design, sd-illustration' + +```bash +python train_localtoon.py --data_dir PATH_TO_YOU_DATA --work_dir PATH_SAVE --style anime +``` @@ -166,7 +377,3 @@ If you find this code useful for your research, please use the following BibTeX - - - - diff --git a/extract_align_faces.py b/extract_align_faces.py new file mode 100644 index 0000000..1620f14 --- /dev/null +++ b/extract_align_faces.py @@ -0,0 +1,162 @@ +import cv2 +import os +import numpy as np +import argparse +from source.facelib.facer import FaceAna +import source.utils as utils +from source.mtcnn_pytorch.src.align_trans import warp_and_crop_face, get_reference_facial_points +from modelscope.hub.snapshot_download import snapshot_download + +class FaceProcesser: + def __init__(self, dataroot, crop_size = 256, max_face = 1): + self.max_face = max_face + self.crop_size = crop_size + self.facer = FaceAna(dataroot) + + def filter_face(self, lm, crop_size): + a = max(lm[:, 0])-min(lm[:, 0]) + b = max(lm[:, 1])-min(lm[:, 1]) + # print("a:%d, b:%d"%(a,b)) + if max(a, b)0: + continue + + if self.filter_face(landmark, self.crop_size)==0: + print("filtered!") + continue + + f5p = utils.get_f5p(landmark, img_bgr) + # face alignment + warped_face, _ = warp_and_crop_face( + img_bgr, + f5p, + ratio=0.75, + reference_pts=get_reference_facial_points(default_square=True), + crop_size=(self.crop_size, self.crop_size), + return_trans_inv=True) + + warped_faces.append(warped_face) + i = i+1 + + + return warped_faces + + + + +if __name__ == "__main__": + + + parser = argparse.ArgumentParser(description="process remove bg result") + parser.add_argument("--src_dir", type=str, default='', help="Path to src images.") + parser.add_argument("--save_dir", type=str, default='', help="Path to save images.") + parser.add_argument("--crop_size", type=int, default=256) + parser.add_argument("--max_face", type=int, default=1) + parser.add_argument("--overwrite", type=int, default=1) + args = parser.parse_args() + args.save_dir = os.path.dirname(args.src_dir) + '/face_cartoon/raw_style_faces' + + crop_size = args.crop_size + max_face = args.max_face + overwrite = args.overwrite + + # model_dir = snapshot_download('damo/cv_unet_person-image-cartoon_compound-models', cache_dir='.') + # print('model assets saved to %s'%model_dir) + model_dir = 'damo/cv_unet_person-image-cartoon_compound-models' + + processer = FaceProcesser(dataroot=model_dir,crop_size=crop_size, max_face =max_face) + + src_dir = args.src_dir + save_dir = args.save_dir + + # print('Step: start to extract aligned faces ... ...') + + print('src_dir:%s'% src_dir) + print('save_dir:%s'% save_dir) + + if not os.path.exists(save_dir): + os.makedirs(save_dir) + + paths = utils.all_file(src_dir) + print('to process %d images'% len(paths)) + + for path in sorted(paths): + dirname = path[len(src_dir)+1:].split('/')[0] + + outpath = save_dir + path[len(src_dir):] + if not overwrite: + if os.path.exists(outpath): + continue + + sub_dir = os.path.dirname(outpath) + # print(sub_dir) + if not os.path.exists(sub_dir): + os.makedirs(sub_dir, exist_ok=True) + + imgb = None + imgc = None + img = cv2.imread(path, -1) + if img is None: + continue + + if len(img.shape)==2: + img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR) + + # print(img.shape) + h,w,c = img.shape + if h<256 or w<256: + continue + imgs = [] + + # if need resize, resize here + img_h, img_w, _ = img.shape + warped_faces = processer.process(img) + if warped_faces is None: + continue + # ### only for anime faces, single, not detect face + # warped_face = imga + + i=0 + for res in warped_faces: + # filter small faces + h, w, c = res.shape + if h < 256 or w < 256: + continue + outpath = os.path.join(os.path.dirname(outpath), os.path.basename(outpath)[:-4] + '_' + str(i) + '.png') + + cv2.imwrite(outpath, res) + print('save %s' % outpath) + i = i+1 + + + + + + + diff --git a/notebooks/fastTrain.ipynb b/notebooks/fastTrain.ipynb new file mode 100644 index 0000000..57905a2 --- /dev/null +++ b/notebooks/fastTrain.ipynb @@ -0,0 +1,215 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "collapsed_sections": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "x[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/menyifang/DCT-Net/blob/main/notebooks/inference.ipynb)" + ], + "metadata": { + "id": "D2MFmZtpVEp_" + } + }, + { + "cell_type": "markdown", + "source": [ + "## Step 1: Installation" + ], + "metadata": { + "id": "zoNN1PYUOUgU" + } + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "7Tv2ZUgrGO6Z" + }, + "outputs": [], + "source": [ + "!pip install numpy==1.18.5\n", + "!pip install torch==1.7.1+cu101 torchvision==0.8.2+cu101 torchaudio==0.7.2 -f https://download.pytorch.org/whl/torch_stable.html\n", + "!pip install --upgrade tensorflow-gpu==1.15 # GPU support, use tensorflow for CPU only\n", + "!pip install \"modelscope[cv]==1.3.0\" -f https://modelscope.oss-cn-beijing.aliyuncs.com/releases/repo.html\n", + "!pip install \"modelscope[multi-modal]==1.3.0\" -f https://modelscope.oss-cn-beijing.aliyuncs.com/releases/repo.html" + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Step 2: Data preparation\n", + "\n", + "style-pretrained diffusion model can be used to produce raw style data (celebrity name -> image)" + ], + "metadata": { + "id": "kTiXDn7_OTMy" + } + }, + { + "cell_type": "code", + "source": [ + "import cv2\n", + "from modelscope.pipelines import pipeline\n", + "from modelscope.utils.constant import Tasks\n", + "\n", + "pipe = pipeline(Tasks.text_to_image_synthesis, model='damo/cv_cartoon_stable_diffusion_clipart', model_revision='v1.0.0')\n", + "from diffusers.schedulers import EulerAncestralDiscreteScheduler\n", + "pipe.pipeline.scheduler = EulerAncestralDiscreteScheduler.from_config(pipe.pipeline.scheduler.config)\n", + "output = pipe({'text': 'archer style, a portrait painting of Johnny Depp'})\n", + "cv2.imwrite('result.png', output['output_imgs'][0])\n", + "print('Image saved to result.png')\n", + "\n", + "print('finished!')" + ], + "metadata": { + "id": "lL2JQBL5Qqjn" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Step 3: Training\n", + "\n", + "fast training of local texture translator with diverse training data:" + ], + "metadata": { + "id": "fShi4lT-ODdE" + } + }, + { + "cell_type": "code", + "source": [ + "import os\n", + "import unittest\n", + "import cv2\n", + "from modelscope.exporters.cv import CartoonTranslationExporter\n", + "from modelscope.msdatasets import MsDataset\n", + "from modelscope.outputs import OutputKeys\n", + "from modelscope.pipelines import pipeline\n", + "from modelscope.pipelines.base import Pipeline\n", + "from modelscope.trainers.cv import CartoonTranslationTrainer\n", + "from modelscope.utils.constant import Tasks\n", + "from modelscope.utils.test_utils import test_level\n", + "\n", + "model_id = 'damo/cv_unet_person-image-cartoon_compound-models'\n", + "data_dir = MsDataset.load(\n", + " 'dctnet_train_clipart_mini_ms',\n", + " namespace='menyifang',\n", + " split='train').config_kwargs['split_config']['train']\n", + "\n", + "# replace data_dir with your own training data\n", + "data_photo = os.path.join(data_dir, 'face_photo')\n", + "data_cartoon = os.path.join(data_dir, 'face_cartoon')\n", + "work_dir = 'exp_localtoon'\n", + "# recomand 30000 steps for real training\n", + "max_steps = 10\n", + "trainer = CartoonTranslationTrainer(\n", + " model=model_id,\n", + " work_dir=work_dir,\n", + " photo=data_photo,\n", + " cartoon=data_cartoon,\n", + " max_steps=max_steps)\n", + "trainer.train()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "k7Llm0SWMLKr", + "outputId": "20b665ce-653e-48a9-c489-d66e93e1907f" + }, + "execution_count": 21, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + } + ] +} \ No newline at end of file diff --git a/prepare_data.sh b/prepare_data.sh new file mode 100644 index 0000000..a00b8ea --- /dev/null +++ b/prepare_data.sh @@ -0,0 +1,45 @@ + +data_root='data' +align_dir='raw_style_data_faces' + +echo "STEP: start to prepare data for stylegan ..." +cd $data_root +if [ ! -d stylegan ]; then + mkdir stylegan +fi +cd stylegan +stylegan_data_dir=$(pwd) +if [ ! -d "$(date +"%Y%m%d")" ]; then + mkdir "$(date +"%Y%m%d")" +fi +cd "$(date +"%Y%m%d")" +cp $align_dir . -r +if [ -d $(echo $align_dir) ]; then + cp $(echo $align_dir) . -r +fi +src_dir_sg=$(pwd) + +cd $data_root/../source +outdir_sg="$(echo $stylegan_data_dir)/traindata_$(echo $stylename)_256_$(date +"%m%d")" +echo $outdir_sg +echo $src_dir_sg +if [ ! -d "$outdir_sg" ]; then + python prepare_data.py --size 256 --out $outdir_sg $src_dir_sg +fi +echo "prepare data for stylegan finished!" + +### train model +#cd $data_root +#cd stylegan +#stylegan_data_dir=$(pwd) +#outdir_sg="$(echo $stylegan_data_dir)/traindata_$(echo $stylename)_256_$(date +"%m%d")" +#echo "STEP:start to train the style learner ..." +#echo $outdir_sg +#exp_name="ffhq_$(echo $stylename)_s256_id01_$(date +"%m%d")" +#cd /data/vdb/qingyao/cartoon/mycode/stylegan2-pytorch +#model_path=face_generation/experiment_stylegan/$(echo $exp_name)/models/001000.pt +#if [ ! -f "$model_path" ]; then +# CUDA_VISIBLE_DEVICES=6 python train_condition.py --name $exp_name --path $outdir_sg --config config/conf_server_train_condition_shell.json +#fi +#### [training...] +#echo "train the style learner finished!" \ No newline at end of file diff --git a/source/.DS_Store b/source/.DS_Store index 81f32a8..0b2490e 100644 Binary files a/source/.DS_Store and b/source/.DS_Store differ diff --git a/source/image_flip_agument_parallel.py b/source/image_flip_agument_parallel.py new file mode 100755 index 0000000..af857c1 --- /dev/null +++ b/source/image_flip_agument_parallel.py @@ -0,0 +1,78 @@ +import oss2 +import argparse +import cv2 +import glob +import os +import tqdm +import numpy as np +# from .utils import get_rmbg_alpha, get_img_from_url,reasonable_resize,major_detection,crop_img +import tqdm +import urllib +import random +from multiprocessing import Pool + + +parser = argparse.ArgumentParser(description="process remove bg result") +parser.add_argument("--data_dir", type=str, default="", help="Path to images.") +parser.add_argument("--save_dir", type=str, default="", help="Path to save images.") +args = parser.parse_args() + + +args.save_dir = os.path.join(args.data_dir, 'total_flip') +form = 'single' + + +def flipImage(image): + new_image = cv2.flip(image, 1) + return new_image + +def all_file(file_dir): + L=[] + for root, dirs, files in os.walk(file_dir): + for file in files: + extend = os.path.splitext(file)[1] + if extend == '.png' or extend == '.jpg' or extend == '.jpeg' or extend == '.JPG': + L.append(os.path.join(root, file)) + return L + + +paths = all_file(args.data_dir) + + +def process(path): + + print(path) + outpath = args.save_dir+path[len(args.data_dir):] + if os.path.exists(outpath): + return + + sub_dir = os.path.dirname(outpath) + # print(sub_dir) + if not os.path.exists(sub_dir): + os.makedirs(sub_dir,exist_ok=True) + + img = cv2.imread(path, -1) + h, w, c = img.shape + if form == "pair": + imga = img[:, :int(w / 2), :] + imgb = img[:, int(w / 2):, :] + imga = flipImage(imga) + imgb = flipImage(imgb) + res = cv2.hconcat([imga, imgb]) # 水平拼接 + + else: + res = flipImage(img) + + cv2.imwrite(outpath, res) + print('save %s' % outpath) + + + + + +if __name__ == "__main__": + # main(args) + pool = Pool(100) + rl = pool.map(process, paths) + pool.close() + pool.join() \ No newline at end of file diff --git a/source/image_rotation_agument_parallel_flat.py b/source/image_rotation_agument_parallel_flat.py new file mode 100755 index 0000000..1aac2d5 --- /dev/null +++ b/source/image_rotation_agument_parallel_flat.py @@ -0,0 +1,101 @@ +import oss2 +import argparse +import cv2 +import glob +import os +import tqdm +import numpy as np +import tqdm +import urllib +import random +from multiprocessing import Pool + + +parser = argparse.ArgumentParser(description="process remove bg result") +parser.add_argument("--data_dir", type=str, default="", help="Path to images.") +parser.add_argument("--save_dir", type=str, default="", help="Path to save images.") +args = parser.parse_args() + + +args.save_dir = os.path.join(args.data_dir, 'total_rotate') +form = 'single' + +if not os.path.exists(args.save_dir): + os.makedirs(args.save_dir,exist_ok=True) + +def all_file(file_dir): + L=[] + for root, dirs, files in os.walk(file_dir): + for file in files: + extend = os.path.splitext(file)[1] + if extend == '.png' or extend == '.jpg' or extend == '.jpeg': + L.append(os.path.join(root, file)) + return L + +def rotateImage(image, angle): + row,col,_ = image.shape + center=tuple(np.array([row,col])/2) + rot_mat = cv2.getRotationMatrix2D(center,angle,1.0) + new_image = cv2.warpAffine(image, rot_mat, (col,row), borderMode=cv2.BORDER_REFLECT) + return new_image + + +paths = all_file(args.data_dir) + + +def process(path): + + if 'total_scale' in path: + return + + outpath = args.save_dir + path[len(args.data_dir):] + sub_dir = os.path.dirname(outpath) + if not os.path.exists(sub_dir): + os.makedirs(sub_dir, exist_ok=True) + + img0 = cv2.imread(path, -1) + h, w, c = img0.shape + img = img0[:, :, :3].copy() + if c == 4: + alpha = img0[:, :, 3] + mask = alpha[:, :, np.newaxis].copy() / 255. + img = (img * mask + (1 - mask) * 255) + + imgb = None + imgc = None + if form is 'single': + imga = img + elif form is 'pair': + imga = img[:, :int(w / 2), :] + imgb = img[:, int(w / 2):, :] + elif form is 'tuple': + imga = img[:, :int(w / 3), :] + imgb = img[:, int(w / 3): int(w * 2 / 3), :] + imgc = img[:, int(w * 2 / 3):, :] + + angles = [ random.randint(-10, 0), random.randint(0, 10)] + + for angle in angles: + + imga_r = rotateImage(imga, angle) + if form is 'single': + res = imga_r + elif form is 'pair': + imgb_r = rotateImage(imgb, angle) + res = cv2.hconcat([imga_r, imgb_r]) # 水平拼接 + else: + imgb_r = rotateImage(imgb, angle) + imgc_r = rotateImage(imgc, angle) + res = cv2.hconcat([imga_r, imgb_r, imgc_r]) # 水平拼接 + + cv2.imwrite(outpath[:-4]+'_'+str(angle)+'.png', res) + print('save %s'% outpath) + + + +if __name__ == "__main__": + # main(args) + pool = Pool(100) + rl = pool.map(process, paths) + pool.close() + pool.join() \ No newline at end of file diff --git a/source/image_scale_agument_parallel_flat.py b/source/image_scale_agument_parallel_flat.py new file mode 100755 index 0000000..74bdc7b --- /dev/null +++ b/source/image_scale_agument_parallel_flat.py @@ -0,0 +1,117 @@ +import oss2 +import argparse +import cv2 +import glob +import os +import tqdm +import numpy as np +import tqdm +import urllib +import random +from multiprocessing import Pool + + +parser = argparse.ArgumentParser(description="process remove bg result") +parser.add_argument("--data_dir", type=str, default="", help="Path to images.") +parser.add_argument("--save_dir", type=str, default="", help="Path to save images.") +args = parser.parse_args() + + +args.save_dir = os.path.join(args.data_dir, 'total_scale') +form = 'single' + +if not os.path.exists(args.save_dir): + os.makedirs(args.save_dir,exist_ok=True) + +def all_file(file_dir): + L=[] + for root, dirs, files in os.walk(file_dir): + for file in files: + extend = os.path.splitext(file)[1] + if extend == '.png' or extend == '.jpg' or extend == '.jpeg': + L.append(os.path.join(root, file)) + return L + +def scaleImage(image, degree): + + h, w, _ = image.shape + canvas = np.ones((h, w, 3), dtype="uint8")*255 + nw, nh = (int(w*degree), int(h*degree)) + image = cv2.resize(image, (nw, nh), interpolation=cv2.INTER_AREA) # w, h + + if degree<1: + canvas[int((h-nh)/2):int((h-nh)/2)+nh, int((w-nw)/2):int((w-nw)/2)+nw,:] = image + elif degree>1: + canvas = image[int((nh-h)/2):int((nh-h)/2)+h, int((nw-w)/2):int((nw-w)/2)+w, :] + else: + canvas = image.copy() + + return canvas + +def scaleImage2(image, degree, angle=0): + row,col,_ = image.shape + center=tuple(np.array([row,col])/2) + rot_mat = cv2.getRotationMatrix2D(center,angle,degree) + new_image = cv2.warpAffine(image, rot_mat, (col,row), borderMode=cv2.BORDER_REFLECT) + return new_image + + +paths = all_file(args.data_dir) + + +def process(path): + + outpath = args.save_dir+path[len(args.data_dir):] + sub_dir = os.path.dirname(outpath) + if not os.path.exists(sub_dir): + os.makedirs(sub_dir, exist_ok=True) + + + img0 = cv2.imread(path, -1) + h, w, c = img0.shape + img = img0[:, :, :3].copy() + if c==4: + alpha = img0[:, :, 3] + mask = alpha[:, :, np.newaxis].copy() / 255. + img = (img * mask + (1 - mask) * 255) + + imgb = None + imgc = None + if form is 'single': + imga = img + elif form is 'pair': + imga = img[:, :int(w / 2), :] + imgb = img[:, int(w / 2):, :] + elif form is 'tuple': + imga = img[:, :int(w / 3), :] + imgb = img[:, int(w / 3): int(w * 2 / 3), :] + imgc = img[:, int(w * 2 / 3):, :] + + if random.random()>0.9: + angles = [random.uniform(1, 1.1)] + else: + angles = [random.uniform(0.8, 1)] + + for angle in angles: + + imga_r = scaleImage(imga, angle) + if form is 'single': + res = imga_r + elif form is 'pair': + imgb_r = scaleImage(imgb, angle) + res = cv2.hconcat([imga_r, imgb_r]) # 水平拼接 + else: + imgb_r = scaleImage(imgb, angle) + imgc_r = scaleImage(imgc, angle) + res = cv2.hconcat([imga_r, imgb_r, imgc_r]) # 水平拼接 + + cv2.imwrite(outpath[:-4]+'_'+str(angle)+'.png', res) + print('save %s'% outpath) + + +if __name__ == "__main__": + # main(args) + pool = Pool(100) + rl = pool.map(process, paths) + pool.close() + pool.join() \ No newline at end of file diff --git a/source/mtcnn_pytorch/.DS_Store b/source/mtcnn_pytorch/.DS_Store new file mode 100644 index 0000000..feca861 Binary files /dev/null and b/source/mtcnn_pytorch/.DS_Store differ diff --git a/source/stylegan2/.DS_Store b/source/stylegan2/.DS_Store new file mode 100644 index 0000000..4fdc34e Binary files /dev/null and b/source/stylegan2/.DS_Store differ diff --git a/source/stylegan2/__init__.py b/source/stylegan2/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/source/stylegan2/config/.DS_Store b/source/stylegan2/config/.DS_Store new file mode 100644 index 0000000..621ff10 Binary files /dev/null and b/source/stylegan2/config/.DS_Store differ diff --git a/source/stylegan2/config/conf_server_test_blend_shell.json b/source/stylegan2/config/conf_server_test_blend_shell.json new file mode 100755 index 0000000..45aa17b --- /dev/null +++ b/source/stylegan2/config/conf_server_test_blend_shell.json @@ -0,0 +1,12 @@ +{ + "parameters": { + "output": "face_generation/experiment_stylegan", + "ffhq_ckpt": "pretrained_models/stylegan2-ffhq-config-f-256-550000.pt", + "size": 256, + "sample": 1, + "pics": 5000, + "truncation": 0.7, + "form": "single" + } +} + diff --git a/source/stylegan2/config/conf_server_train_condition_shell.json b/source/stylegan2/config/conf_server_train_condition_shell.json new file mode 100755 index 0000000..0245bae --- /dev/null +++ b/source/stylegan2/config/conf_server_train_condition_shell.json @@ -0,0 +1,14 @@ +{ + "parameters": { + "output": "face_generation/experiment_stylegan", + "ckpt": "pretrained_models/stylegan2-ffhq-config-f-256-550000.pt", + "ckpt_ffhq": "pretrained_models/stylegan2-ffhq-config-f-256-550000.pt", + "size": 256, + "batch": 8, + "n_sample": 4, + "iter": 1500, + "sample_every": 100, + "save_every": 100 + } +} + diff --git a/source/stylegan2/criteria/__init__.py b/source/stylegan2/criteria/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/source/stylegan2/criteria/helpers.py b/source/stylegan2/criteria/helpers.py new file mode 100755 index 0000000..b51fdf9 --- /dev/null +++ b/source/stylegan2/criteria/helpers.py @@ -0,0 +1,119 @@ +from collections import namedtuple +import torch +from torch.nn import Conv2d, BatchNorm2d, PReLU, ReLU, Sigmoid, MaxPool2d, AdaptiveAvgPool2d, Sequential, Module + +""" +ArcFace implementation from [TreB1eN](https://github.com/TreB1eN/InsightFace_Pytorch) +""" + + +class Flatten(Module): + def forward(self, input): + return input.view(input.size(0), -1) + + +def l2_norm(input, axis=1): + norm = torch.norm(input, 2, axis, True) + output = torch.div(input, norm) + return output + + +class Bottleneck(namedtuple('Block', ['in_channel', 'depth', 'stride'])): + """ A named tuple describing a ResNet block. """ + + +def get_block(in_channel, depth, num_units, stride=2): + return [Bottleneck(in_channel, depth, stride)] + [Bottleneck(depth, depth, 1) for i in range(num_units - 1)] + + +def get_blocks(num_layers): + if num_layers == 50: + blocks = [ + get_block(in_channel=64, depth=64, num_units=3), + get_block(in_channel=64, depth=128, num_units=4), + get_block(in_channel=128, depth=256, num_units=14), + get_block(in_channel=256, depth=512, num_units=3) + ] + elif num_layers == 100: + blocks = [ + get_block(in_channel=64, depth=64, num_units=3), + get_block(in_channel=64, depth=128, num_units=13), + get_block(in_channel=128, depth=256, num_units=30), + get_block(in_channel=256, depth=512, num_units=3) + ] + elif num_layers == 152: + blocks = [ + get_block(in_channel=64, depth=64, num_units=3), + get_block(in_channel=64, depth=128, num_units=8), + get_block(in_channel=128, depth=256, num_units=36), + get_block(in_channel=256, depth=512, num_units=3) + ] + else: + raise ValueError("Invalid number of layers: {}. Must be one of [50, 100, 152]".format(num_layers)) + return blocks + + +class SEModule(Module): + def __init__(self, channels, reduction): + super(SEModule, self).__init__() + self.avg_pool = AdaptiveAvgPool2d(1) + self.fc1 = Conv2d(channels, channels // reduction, kernel_size=1, padding=0, bias=False) + self.relu = ReLU(inplace=True) + self.fc2 = Conv2d(channels // reduction, channels, kernel_size=1, padding=0, bias=False) + self.sigmoid = Sigmoid() + + def forward(self, x): + module_input = x + x = self.avg_pool(x) + x = self.fc1(x) + x = self.relu(x) + x = self.fc2(x) + x = self.sigmoid(x) + return module_input * x + + +class bottleneck_IR(Module): + def __init__(self, in_channel, depth, stride): + super(bottleneck_IR, self).__init__() + if in_channel == depth: + self.shortcut_layer = MaxPool2d(1, stride) + else: + self.shortcut_layer = Sequential( + Conv2d(in_channel, depth, (1, 1), stride, bias=False), + BatchNorm2d(depth) + ) + self.res_layer = Sequential( + BatchNorm2d(in_channel), + Conv2d(in_channel, depth, (3, 3), (1, 1), 1, bias=False), PReLU(depth), + Conv2d(depth, depth, (3, 3), stride, 1, bias=False), BatchNorm2d(depth) + ) + + def forward(self, x): + shortcut = self.shortcut_layer(x) + res = self.res_layer(x) + return res + shortcut + + +class bottleneck_IR_SE(Module): + def __init__(self, in_channel, depth, stride): + super(bottleneck_IR_SE, self).__init__() + if in_channel == depth: + self.shortcut_layer = MaxPool2d(1, stride) + else: + self.shortcut_layer = Sequential( + Conv2d(in_channel, depth, (1, 1), stride, bias=False), + BatchNorm2d(depth) + ) + self.res_layer = Sequential( + BatchNorm2d(in_channel), + Conv2d(in_channel, depth, (3, 3), (1, 1), 1, bias=False), + PReLU(depth), + Conv2d(depth, depth, (3, 3), stride, 1, bias=False), + BatchNorm2d(depth), + SEModule(depth, 16) + ) + + def forward(self, x): + shortcut = self.shortcut_layer(x) + res = self.res_layer(x) + return res + shortcut diff --git a/source/stylegan2/criteria/id_loss.py b/source/stylegan2/criteria/id_loss.py new file mode 100755 index 0000000..3b0095c --- /dev/null +++ b/source/stylegan2/criteria/id_loss.py @@ -0,0 +1,40 @@ +import torch +from torch import nn +from .model_irse import Backbone + + +class IDLoss(nn.Module): + def __init__(self): + super(IDLoss, self).__init__() + print('Loading ResNet ArcFace') + model_paths = '/data/vdb/qingyao/cartoon/mycode/pretrained_models/model_ir_se50.pth' + self.facenet = Backbone(input_size=112, num_layers=50, drop_ratio=0.6, mode='ir_se') + self.facenet.load_state_dict(torch.load(model_paths)) + self.face_pool = torch.nn.AdaptiveAvgPool2d((112, 112)) + self.facenet.eval() + + def extract_feats(self, x): + x = x[:, :, 35:223, 32:220] # Crop interesting region + x = self.face_pool(x) + x_feats = self.facenet(x) + return x_feats + + def forward(self, y_hat, x): + n_samples = x.shape[0] + x_feats = self.extract_feats(x) + y_hat_feats = self.extract_feats(y_hat) + loss = 0 + sim_improvement = 0 + id_logs = [] + count = 0 + for i in range(n_samples): + diff_input = y_hat_feats[i].dot(x_feats[i]) + id_logs.append({ + 'diff_input': float(diff_input) + }) + # loss += 1 - diff_target + # modify + loss += 1 - diff_input + count += 1 + + return loss / count diff --git a/source/stylegan2/criteria/lpips/__init__.py b/source/stylegan2/criteria/lpips/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/source/stylegan2/criteria/lpips/lpips.py b/source/stylegan2/criteria/lpips/lpips.py new file mode 100755 index 0000000..36b220b --- /dev/null +++ b/source/stylegan2/criteria/lpips/lpips.py @@ -0,0 +1,35 @@ +import torch +import torch.nn as nn + +from criteria.lpips.networks import get_network, LinLayers +from criteria.lpips.utils import get_state_dict + + +class LPIPS(nn.Module): + r"""Creates a criterion that measures + Learned Perceptual Image Patch Similarity (LPIPS). + Arguments: + net_type (str): the network type to compare the features: + 'alex' | 'squeeze' | 'vgg'. Default: 'alex'. + version (str): the version of LPIPS. Default: 0.1. + """ + def __init__(self, net_type: str = 'alex', version: str = '0.1'): + + assert version in ['0.1'], 'v0.1 is only supported now' + + super(LPIPS, self).__init__() + + # pretrained network + self.net = get_network(net_type).to("cuda") + + # linear layers + self.lin = LinLayers(self.net.n_channels_list).to("cuda") + self.lin.load_state_dict(get_state_dict(net_type, version)) + + def forward(self, x: torch.Tensor, y: torch.Tensor): + feat_x, feat_y = self.net(x), self.net(y) + + diff = [(fx - fy) ** 2 for fx, fy in zip(feat_x, feat_y)] + res = [l(d).mean((2, 3), True) for d, l in zip(diff, self.lin)] + + return torch.sum(torch.cat(res, 0)) / x.shape[0] diff --git a/source/stylegan2/criteria/lpips/networks.py b/source/stylegan2/criteria/lpips/networks.py new file mode 100755 index 0000000..7b182d0 --- /dev/null +++ b/source/stylegan2/criteria/lpips/networks.py @@ -0,0 +1,96 @@ +from typing import Sequence + +from itertools import chain + +import torch +import torch.nn as nn +from torchvision import models + +from criteria.lpips.utils import normalize_activation + + +def get_network(net_type: str): + if net_type == 'alex': + return AlexNet() + elif net_type == 'squeeze': + return SqueezeNet() + elif net_type == 'vgg': + return VGG16() + else: + raise NotImplementedError('choose net_type from [alex, squeeze, vgg].') + + +class LinLayers(nn.ModuleList): + def __init__(self, n_channels_list: Sequence[int]): + super(LinLayers, self).__init__([ + nn.Sequential( + nn.Identity(), + nn.Conv2d(nc, 1, 1, 1, 0, bias=False) + ) for nc in n_channels_list + ]) + + for param in self.parameters(): + param.requires_grad = False + + +class BaseNet(nn.Module): + def __init__(self): + super(BaseNet, self).__init__() + + # register buffer + self.register_buffer( + 'mean', torch.Tensor([-.030, -.088, -.188])[None, :, None, None]) + self.register_buffer( + 'std', torch.Tensor([.458, .448, .450])[None, :, None, None]) + + def set_requires_grad(self, state: bool): + for param in chain(self.parameters(), self.buffers()): + param.requires_grad = state + + def z_score(self, x: torch.Tensor): + return (x - self.mean) / self.std + + def forward(self, x: torch.Tensor): + x = self.z_score(x) + + output = [] + for i, (_, layer) in enumerate(self.layers._modules.items(), 1): + x = layer(x) + if i in self.target_layers: + output.append(normalize_activation(x)) + if len(output) == len(self.target_layers): + break + return output + + +class SqueezeNet(BaseNet): + def __init__(self): + super(SqueezeNet, self).__init__() + + self.layers = models.squeezenet1_1(True).features + self.target_layers = [2, 5, 8, 10, 11, 12, 13] + self.n_channels_list = [64, 128, 256, 384, 384, 512, 512] + + self.set_requires_grad(False) + + +class AlexNet(BaseNet): + def __init__(self): + super(AlexNet, self).__init__() + + self.layers = models.alexnet(True).features + self.target_layers = [2, 5, 8, 10, 12] + self.n_channels_list = [64, 192, 384, 256, 256] + + self.set_requires_grad(False) + + +class VGG16(BaseNet): + def __init__(self): + super(VGG16, self).__init__() + + self.layers = models.vgg16(True).features + self.target_layers = [4, 9, 16, 23, 30] + self.n_channels_list = [64, 128, 256, 512, 512] + + self.set_requires_grad(False) \ No newline at end of file diff --git a/source/stylegan2/criteria/lpips/utils.py b/source/stylegan2/criteria/lpips/utils.py new file mode 100755 index 0000000..28f1867 --- /dev/null +++ b/source/stylegan2/criteria/lpips/utils.py @@ -0,0 +1,30 @@ +from collections import OrderedDict + +import torch + + +def normalize_activation(x, eps=1e-10): + norm_factor = torch.sqrt(torch.sum(x ** 2, dim=1, keepdim=True)) + return x / (norm_factor + eps) + + +def get_state_dict(net_type: str = 'alex', version: str = '0.1'): + # build url + url = 'https://raw.githubusercontent.com/richzhang/PerceptualSimilarity/' \ + + f'master/lpips/weights/v{version}/{net_type}.pth' + + # download + old_state_dict = torch.hub.load_state_dict_from_url( + url, progress=True, + map_location=None if torch.cuda.is_available() else torch.device('cpu') + ) + + # rename keys + new_state_dict = OrderedDict() + for key, val in old_state_dict.items(): + new_key = key + new_key = new_key.replace('lin', '') + new_key = new_key.replace('model.', '') + new_state_dict[new_key] = val + + return new_state_dict diff --git a/source/stylegan2/criteria/moco_loss.py b/source/stylegan2/criteria/moco_loss.py new file mode 100644 index 0000000..4e6f04d --- /dev/null +++ b/source/stylegan2/criteria/moco_loss.py @@ -0,0 +1,69 @@ +import torch +from torch import nn +import torch.nn.functional as F +from configs.paths_config import model_paths + + +class MocoLoss(nn.Module): + + def __init__(self): + super(MocoLoss, self).__init__() + print("Loading MOCO model from path: {}".format(model_paths["moco"])) + self.model = self.__load_model() + self.model.cuda() + self.model.eval() + + @staticmethod + def __load_model(): + import torchvision.models as models + model = models.__dict__["resnet50"]() + # freeze all layers but the last fc + for name, param in model.named_parameters(): + if name not in ['fc.weight', 'fc.bias']: + param.requires_grad = False + checkpoint = torch.load(model_paths['moco'], map_location="cpu") + state_dict = checkpoint['state_dict'] + # rename moco pre-trained keys + for k in list(state_dict.keys()): + # retain only encoder_q up to before the embedding layer + if k.startswith('module.encoder_q') and not k.startswith('module.encoder_q.fc'): + # remove prefix + state_dict[k[len("module.encoder_q."):]] = state_dict[k] + # delete renamed or unused k + del state_dict[k] + msg = model.load_state_dict(state_dict, strict=False) + assert set(msg.missing_keys) == {"fc.weight", "fc.bias"} + # remove output layer + model = nn.Sequential(*list(model.children())[:-1]).cuda() + return model + + def extract_feats(self, x): + x = F.interpolate(x, size=224) + x_feats = self.model(x) + x_feats = nn.functional.normalize(x_feats, dim=1) + x_feats = x_feats.squeeze() + return x_feats + + def forward(self, y_hat, y, x): + n_samples = x.shape[0] + x_feats = self.extract_feats(x) + y_feats = self.extract_feats(y) + y_hat_feats = self.extract_feats(y_hat) + y_feats = y_feats.detach() + loss = 0 + sim_improvement = 0 + sim_logs = [] + count = 0 + for i in range(n_samples): + diff_target = y_hat_feats[i].dot(y_feats[i]) + diff_input = y_hat_feats[i].dot(x_feats[i]) + diff_views = y_feats[i].dot(x_feats[i]) + sim_logs.append({'diff_target': float(diff_target), + 'diff_input': float(diff_input), + 'diff_views': float(diff_views)}) + loss += 1 - diff_target + sim_diff = float(diff_target) - float(diff_views) + sim_improvement += sim_diff + count += 1 + + return loss / count, sim_improvement / count, sim_logs diff --git a/source/stylegan2/criteria/model_irse.py b/source/stylegan2/criteria/model_irse.py new file mode 100755 index 0000000..8a61e0d --- /dev/null +++ b/source/stylegan2/criteria/model_irse.py @@ -0,0 +1,84 @@ +from torch.nn import Linear, Conv2d, BatchNorm1d, BatchNorm2d, PReLU, Dropout, Sequential, Module +from .helpers import get_blocks, Flatten, bottleneck_IR, bottleneck_IR_SE, l2_norm + +""" +Modified Backbone implementation from [TreB1eN](https://github.com/TreB1eN/InsightFace_Pytorch) +""" + + +class Backbone(Module): + def __init__(self, input_size, num_layers, mode='ir', drop_ratio=0.4, affine=True): + super(Backbone, self).__init__() + assert input_size in [112, 224], "input_size should be 112 or 224" + assert num_layers in [50, 100, 152], "num_layers should be 50, 100 or 152" + assert mode in ['ir', 'ir_se'], "mode should be ir or ir_se" + blocks = get_blocks(num_layers) + if mode == 'ir': + unit_module = bottleneck_IR + elif mode == 'ir_se': + unit_module = bottleneck_IR_SE + self.input_layer = Sequential(Conv2d(3, 64, (3, 3), 1, 1, bias=False), + BatchNorm2d(64), + PReLU(64)) + if input_size == 112: + self.output_layer = Sequential(BatchNorm2d(512), + Dropout(drop_ratio), + Flatten(), + Linear(512 * 7 * 7, 512), + BatchNorm1d(512, affine=affine)) + else: + self.output_layer = Sequential(BatchNorm2d(512), + Dropout(drop_ratio), + Flatten(), + Linear(512 * 14 * 14, 512), + BatchNorm1d(512, affine=affine)) + + modules = [] + for block in blocks: + for bottleneck in block: + modules.append(unit_module(bottleneck.in_channel, + bottleneck.depth, + bottleneck.stride)) + self.body = Sequential(*modules) + + def forward(self, x): + x = self.input_layer(x) + x = self.body(x) + x = self.output_layer(x) + return l2_norm(x) + + +def IR_50(input_size): + """Constructs a ir-50 model.""" + model = Backbone(input_size, num_layers=50, mode='ir', drop_ratio=0.4, affine=False) + return model + + +def IR_101(input_size): + """Constructs a ir-101 model.""" + model = Backbone(input_size, num_layers=100, mode='ir', drop_ratio=0.4, affine=False) + return model + + +def IR_152(input_size): + """Constructs a ir-152 model.""" + model = Backbone(input_size, num_layers=152, mode='ir', drop_ratio=0.4, affine=False) + return model + + +def IR_SE_50(input_size): + """Constructs a ir_se-50 model.""" + model = Backbone(input_size, num_layers=50, mode='ir_se', drop_ratio=0.4, affine=False) + return model + + +def IR_SE_101(input_size): + """Constructs a ir_se-101 model.""" + model = Backbone(input_size, num_layers=100, mode='ir_se', drop_ratio=0.4, affine=False) + return model + + +def IR_SE_152(input_size): + """Constructs a ir_se-152 model.""" + model = Backbone(input_size, num_layers=152, mode='ir_se', drop_ratio=0.4, affine=False) + return model diff --git a/source/stylegan2/criteria/vgg.py b/source/stylegan2/criteria/vgg.py new file mode 100755 index 0000000..1b78988 --- /dev/null +++ b/source/stylegan2/criteria/vgg.py @@ -0,0 +1,83 @@ +import torch +from torch.autograd import Variable +import torch.nn as nn +import torch.nn.functional as F +from torch import optim + +from PIL import Image +import os + + +# gram matrix and loss +class GramMatrix(nn.Module): + def forward(self, input): + b, c, h, w = input.size() + F = input.view(b, c, h * w) + G = torch.bmm(F, F.transpose(1, 2)) + G.div_(h * w) + return G + + +class GramMSELoss(nn.Module): + def forward(self, input, target): + out = nn.MSELoss()(GramMatrix()(input), target) + return (out) + + +# vgg definition that conveniently let's you grab the outputs from any layer +class VGG(nn.Module): + def __init__(self, pool='max'): + super(VGG, self).__init__() + # vgg modules + self.conv1_1 = nn.Conv2d(3, 64, kernel_size=3, padding=1) + self.conv1_2 = nn.Conv2d(64, 64, kernel_size=3, padding=1) + self.conv2_1 = nn.Conv2d(64, 128, kernel_size=3, padding=1) + self.conv2_2 = nn.Conv2d(128, 128, kernel_size=3, padding=1) + self.conv3_1 = nn.Conv2d(128, 256, kernel_size=3, padding=1) + self.conv3_2 = nn.Conv2d(256, 256, kernel_size=3, padding=1) + self.conv3_3 = nn.Conv2d(256, 256, kernel_size=3, padding=1) + self.conv3_4 = nn.Conv2d(256, 256, kernel_size=3, padding=1) + self.conv4_1 = nn.Conv2d(256, 512, kernel_size=3, padding=1) + self.conv4_2 = nn.Conv2d(512, 512, kernel_size=3, padding=1) + self.conv4_3 = nn.Conv2d(512, 512, kernel_size=3, padding=1) + self.conv4_4 = nn.Conv2d(512, 512, kernel_size=3, padding=1) + self.conv5_1 = nn.Conv2d(512, 512, kernel_size=3, padding=1) + self.conv5_2 = nn.Conv2d(512, 512, kernel_size=3, padding=1) + self.conv5_3 = nn.Conv2d(512, 512, kernel_size=3, padding=1) + self.conv5_4 = nn.Conv2d(512, 512, kernel_size=3, padding=1) + + if pool == 'max': + self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2) + self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2) + self.pool3 = nn.MaxPool2d(kernel_size=2, stride=2) + self.pool4 = nn.MaxPool2d(kernel_size=2, stride=2) + self.pool5 = nn.MaxPool2d(kernel_size=2, stride=2) + + elif pool == 'avg': + self.pool1 = nn.AvgPool2d(kernel_size=2, stride=2) + self.pool2 = nn.AvgPool2d(kernel_size=2, stride=2) + self.pool3 = nn.AvgPool2d(kernel_size=2, stride=2) + self.pool4 = nn.AvgPool2d(kernel_size=2, stride=2) + self.pool5 = nn.AvgPool2d(kernel_size=2, stride=2) + + + def forward(self, x): + out = {} + out['r11'] = F.relu(self.conv1_1(x)) + out['r12'] = F.relu(self.conv1_2(out['r11'])) + out['p1'] = self.pool1(out['r12']) + out['r21'] = F.relu(self.conv2_1(out['p1'])) + out['r22'] = F.relu(self.conv2_2(out['r21'])) + out['p2'] = self.pool2(out['r22']) + out['r31'] = F.relu(self.conv3_1(out['p2'])) + out['r32'] = F.relu(self.conv3_2(out['r31'])) + out['r33'] = F.relu(self.conv3_3(out['r32'])) + out['r34'] = F.relu(self.conv3_4(out['r33'])) + out['p3'] = self.pool3(out['r34']) + out['r41'] = F.relu(self.conv4_1(out['p3'])) + out['r42'] = F.relu(self.conv4_2(out['r41'])) + out['r43'] = F.relu(self.conv4_3(out['r42'])) + conv_4_4 = self.conv4_4(out['r43']) + out['r44'] = F.relu(conv_4_4) + out['p4'] = self.pool4(out['r44']) + return conv_4_4 \ No newline at end of file diff --git a/source/stylegan2/criteria/vgg_loss.py b/source/stylegan2/criteria/vgg_loss.py new file mode 100755 index 0000000..f0cc09b --- /dev/null +++ b/source/stylegan2/criteria/vgg_loss.py @@ -0,0 +1,30 @@ +import torch +from torch import nn +from .vgg import VGG +import os +from configs.paths_config import model_paths + +class VggLoss(nn.Module): + def __init__(self): + super(VggLoss, self).__init__() + print("Loading VGG19 model from path: {}".format(model_paths["vgg"])) + + self.vgg_model = VGG() + self.vgg_model.load_state_dict(torch.load(model_paths['vgg'])) + self.vgg_model.cuda() + self.vgg_model.eval() + + self.l1loss = torch.nn.L1Loss() + + + + + + def forward(self, input_photo, output): + vgg_photo = self.vgg_model(input_photo) + vgg_output = self.vgg_model(output) + n, c, h, w = vgg_photo.shape + # h, w, c = vgg_photo.get_shape().as_list()[1:] + loss = self.l1loss(vgg_photo, vgg_output) + + return loss diff --git a/source/stylegan2/criteria/w_norm.py b/source/stylegan2/criteria/w_norm.py new file mode 100755 index 0000000..a45ab6f --- /dev/null +++ b/source/stylegan2/criteria/w_norm.py @@ -0,0 +1,14 @@ +import torch +from torch import nn + + +class WNormLoss(nn.Module): + + def __init__(self, start_from_latent_avg=True): + super(WNormLoss, self).__init__() + self.start_from_latent_avg = start_from_latent_avg + + def forward(self, latent, latent_avg=None): + if self.start_from_latent_avg: + latent = latent - latent_avg + return torch.sum(latent.norm(2, dim=(1, 2))) / latent.shape[0] diff --git a/source/stylegan2/dataset.py b/source/stylegan2/dataset.py new file mode 100755 index 0000000..7713ea2 --- /dev/null +++ b/source/stylegan2/dataset.py @@ -0,0 +1,40 @@ +from io import BytesIO + +import lmdb +from PIL import Image +from torch.utils.data import Dataset + + +class MultiResolutionDataset(Dataset): + def __init__(self, path, transform, resolution=256): + self.env = lmdb.open( + path, + max_readers=32, + readonly=True, + lock=False, + readahead=False, + meminit=False, + ) + + if not self.env: + raise IOError('Cannot open lmdb dataset', path) + + with self.env.begin(write=False) as txn: + self.length = int(txn.get('length'.encode('utf-8')).decode('utf-8')) + + self.resolution = resolution + self.transform = transform + + def __len__(self): + return self.length + + def __getitem__(self, index): + with self.env.begin(write=False) as txn: + key = f'{self.resolution}-{str(index).zfill(5)}'.encode('utf-8') + img_bytes = txn.get(key) + + buffer = BytesIO(img_bytes) + img = Image.open(buffer) + img = self.transform(img) + + return img diff --git a/source/stylegan2/distributed.py b/source/stylegan2/distributed.py new file mode 100755 index 0000000..51fa243 --- /dev/null +++ b/source/stylegan2/distributed.py @@ -0,0 +1,126 @@ +import math +import pickle + +import torch +from torch import distributed as dist +from torch.utils.data.sampler import Sampler + + +def get_rank(): + if not dist.is_available(): + return 0 + + if not dist.is_initialized(): + return 0 + + return dist.get_rank() + + +def synchronize(): + if not dist.is_available(): + return + + if not dist.is_initialized(): + return + + world_size = dist.get_world_size() + + if world_size == 1: + return + + dist.barrier() + + +def get_world_size(): + if not dist.is_available(): + return 1 + + if not dist.is_initialized(): + return 1 + + return dist.get_world_size() + + +def reduce_sum(tensor): + if not dist.is_available(): + return tensor + + if not dist.is_initialized(): + return tensor + + tensor = tensor.clone() + dist.all_reduce(tensor, op=dist.ReduceOp.SUM) + + return tensor + + +def gather_grad(params): + world_size = get_world_size() + + if world_size == 1: + return + + for param in params: + if param.grad is not None: + dist.all_reduce(param.grad.data, op=dist.ReduceOp.SUM) + param.grad.data.div_(world_size) + + +def all_gather(data): + world_size = get_world_size() + + if world_size == 1: + return [data] + + buffer = pickle.dumps(data) + storage = torch.ByteStorage.from_buffer(buffer) + tensor = torch.ByteTensor(storage).to('cuda') + + local_size = torch.IntTensor([tensor.numel()]).to('cuda') + size_list = [torch.IntTensor([0]).to('cuda') for _ in range(world_size)] + dist.all_gather(size_list, local_size) + size_list = [int(size.item()) for size in size_list] + max_size = max(size_list) + + tensor_list = [] + for _ in size_list: + tensor_list.append(torch.ByteTensor(size=(max_size,)).to('cuda')) + + if local_size != max_size: + padding = torch.ByteTensor(size=(max_size - local_size,)).to('cuda') + tensor = torch.cat((tensor, padding), 0) + + dist.all_gather(tensor_list, tensor) + + data_list = [] + + for size, tensor in zip(size_list, tensor_list): + buffer = tensor.cpu().numpy().tobytes()[:size] + data_list.append(pickle.loads(buffer)) + + return data_list + + +def reduce_loss_dict(loss_dict): + world_size = get_world_size() + + if world_size < 2: + return loss_dict + + with torch.no_grad(): + keys = [] + losses = [] + + for k in sorted(loss_dict.keys()): + keys.append(k) + losses.append(loss_dict[k]) + + losses = torch.stack(losses, 0) + dist.reduce(losses, dst=0) + + if dist.get_rank() == 0: + losses /= world_size + + reduced_losses = {k: v for k, v in zip(keys, losses)} + + return reduced_losses diff --git a/source/stylegan2/generate_blendmodel.py b/source/stylegan2/generate_blendmodel.py new file mode 100755 index 0000000..4ab885c --- /dev/null +++ b/source/stylegan2/generate_blendmodel.py @@ -0,0 +1,147 @@ +import argparse +import os +os.environ["CUDA_VISIBLE_DEVICES"] = "7" +import torch +from torchvision import utils +from model import Generator +from tqdm import tqdm +import json +import glob + +from PIL import Image + +def make_image(tensor): + return ( + tensor.detach() + .clamp_(min=-1, max=1) + .add(1) + .div_(2) + .mul(255) + .type(torch.uint8) + .permute(0, 2, 3, 1) + .to("cpu") + .numpy() + ) + +def generate(args, g_ema, device, mean_latent, model_name, g_ema_ffhq): + + outdir = args.save_dir + + # print(outdir) + # outdir = os.path.join(args.output, args.name, 'eval','toons_paired_0512') + if not os.path.exists(outdir): + os.makedirs(outdir) + + with torch.no_grad(): + g_ema.eval() + for i in tqdm(range(args.pics)): + sample_z = torch.randn(args.sample, args.latent, device=device) + + res, _ = g_ema( + [sample_z], truncation=args.truncation, truncation_latent=mean_latent + ) + if args.form == "pair": + sample_face, _ = g_ema_ffhq( + [sample_z], truncation=args.truncation, truncation_latent=mean_latent + ) + res = torch.cat([sample_face, res], 3) + + outpath = os.path.join(outdir, str(i).zfill(6)+'.png') + utils.save_image( + res, + outpath, + # f"sample/{str(i).zfill(6)}.png", + nrow=1, + normalize=True, + range=(-1, 1), + ) + # print('save %s'% outpath) + + + + +if __name__ == "__main__": + device = "cuda" + + parser = argparse.ArgumentParser(description="Generate samples from the generator") + parser.add_argument('--config', type=str, default='config/conf_server_test_blend_shell.json') + parser.add_argument('--name', type=str, default='') + parser.add_argument('--save_dir', type=str, default='') + + parser.add_argument('--form', type=str, default='single') + parser.add_argument( + "--size", type=int, default=256, help="output image size of the generator" + ) + parser.add_argument( + "--sample", + type=int, + default=1, + help="number of samples to be generated for each image", + ) + parser.add_argument( + "--pics", type=int, default=20, help="number of images to be generated" + ) + parser.add_argument("--truncation", type=float, default=1, help="truncation ratio") + parser.add_argument( + "--truncation_mean", + type=int, + default=4096, + help="number of vectors to calculate mean for the truncation", + ) + parser.add_argument( + "--ckpt", + type=str, + default="stylegan2-ffhq-config-f.pt", + help="path to the model checkpoint", + ) + parser.add_argument( + "--channel_multiplier", + type=int, + default=2, + help="channel multiplier of the generator. config-f = 2, else = 1", + ) + + args = parser.parse_args() + # from config updata paras + opt = vars(args) + with open(args.config) as f: + config = json.load(f)['parameters'] + for key, value in config.items(): + opt[key] = value + + # args.ckpt = 'face_generation/experiment_stylegan/'+args.name+'/models_blend/G_blend_001000_4.pt' + args.ckpt = 'face_generation/experiment_stylegan/'+args.name+'/models_blend/G_blend_' + args.ckpt = glob.glob(args.ckpt+'*')[0] + + args.latent = 512 + args.n_mlp = 8 + + g_ema = Generator( + args.size, args.latent, args.n_mlp, channel_multiplier=args.channel_multiplier + ).to(device) + checkpoint = torch.load(args.ckpt) + + # g_ema.load_state_dict(checkpoint["g_ema"]) + g_ema.load_state_dict(checkpoint["g_ema"], strict=False) + + ## add G_ffhq + g_ema_ffhq = Generator( + args.size, args.latent, args.n_mlp, channel_multiplier=args.channel_multiplier + ).to(device) + checkpoint_ffhq = torch.load(args.ffhq_ckpt) + g_ema_ffhq.load_state_dict(checkpoint_ffhq["g_ema"], strict=False) + + + if args.truncation < 1: + with torch.no_grad(): + mean_latent = g_ema.mean_latent(args.truncation_mean) + else: + mean_latent = None + + model_name = os.path.basename(args.ckpt) + print('save generated samples to %s'% os.path.join(args.output, args.name, 'eval_blend', model_name)) + generate(args, g_ema, device, mean_latent, model_name, g_ema_ffhq) + # generate_style_mix(args, g_ema, device, mean_latent, model_name, g_ema_ffhq) + + # latent_path = 'test2.pt' + # generate_from_latent(args, g_ema, device, mean_latent, latent_path) diff --git a/source/stylegan2/model.py b/source/stylegan2/model.py new file mode 100755 index 0000000..61bfb30 --- /dev/null +++ b/source/stylegan2/model.py @@ -0,0 +1,939 @@ +import math +import random +import functools +import operator +import copy + +import torch +from torch import nn +from torch.nn import functional as F +from torch.autograd import Function + +from op import FusedLeakyReLU, fused_leaky_relu, upfirdn2d, conv2d_gradfix + + +class PixelNorm(nn.Module): + def __init__(self): + super().__init__() + + def forward(self, input): + return input * torch.rsqrt(torch.mean(input ** 2, dim=1, keepdim=True) + 1e-8) + + +def make_kernel(k): + k = torch.tensor(k, dtype=torch.float32) + + if k.ndim == 1: + k = k[None, :] * k[:, None] + + k /= k.sum() + + return k + + +class Upsample(nn.Module): + def __init__(self, kernel, factor=2): + super().__init__() + + self.factor = factor + kernel = make_kernel(kernel) * (factor ** 2) + self.register_buffer("kernel", kernel) + + p = kernel.shape[0] - factor + + pad0 = (p + 1) // 2 + factor - 1 + pad1 = p // 2 + + self.pad = (pad0, pad1) + + def forward(self, input): + out = upfirdn2d(input, self.kernel, up=self.factor, down=1, pad=self.pad) + + return out + + +class Downsample(nn.Module): + def __init__(self, kernel, factor=2): + super().__init__() + + self.factor = factor + kernel = make_kernel(kernel) + self.register_buffer("kernel", kernel) + + p = kernel.shape[0] - factor + + pad0 = (p + 1) // 2 + pad1 = p // 2 + + self.pad = (pad0, pad1) + + def forward(self, input): + out = upfirdn2d(input, self.kernel, up=1, down=self.factor, pad=self.pad) + + return out + + +class Blur(nn.Module): + def __init__(self, kernel, pad, upsample_factor=1): + super().__init__() + + kernel = make_kernel(kernel) + + if upsample_factor > 1: + kernel = kernel * (upsample_factor ** 2) + + self.register_buffer("kernel", kernel) + + self.pad = pad + + def forward(self, input): + out = upfirdn2d(input, self.kernel, pad=self.pad) + + return out + + +class EqualConv2d(nn.Module): + def __init__( + self, in_channel, out_channel, kernel_size, stride=1, padding=0, bias=True + ): + super().__init__() + + self.weight = nn.Parameter( + torch.randn(out_channel, in_channel, kernel_size, kernel_size) + ) + self.scale = 1 / math.sqrt(in_channel * kernel_size ** 2) + + self.stride = stride + self.padding = padding + + if bias: + self.bias = nn.Parameter(torch.zeros(out_channel)) + + else: + self.bias = None + + def forward(self, input): + out = conv2d_gradfix.conv2d( + input, + self.weight * self.scale, + bias=self.bias, + stride=self.stride, + padding=self.padding, + ) + + return out + + def __repr__(self): + return ( + f"{self.__class__.__name__}({self.weight.shape[1]}, {self.weight.shape[0]}," + f" {self.weight.shape[2]}, stride={self.stride}, padding={self.padding})" + ) + + +class EqualLinear(nn.Module): + def __init__( + self, in_dim, out_dim, bias=True, bias_init=0, lr_mul=1, activation=None + ): + super().__init__() + + self.weight = nn.Parameter(torch.randn(out_dim, in_dim).div_(lr_mul)) + + if bias: + self.bias = nn.Parameter(torch.zeros(out_dim).fill_(bias_init)) + + else: + self.bias = None + + self.activation = activation + + self.scale = (1 / math.sqrt(in_dim)) * lr_mul + self.lr_mul = lr_mul + + def forward(self, input): + if self.activation: + out = F.linear(input, self.weight * self.scale) + out = fused_leaky_relu(out, self.bias * self.lr_mul) + + else: + out = F.linear( + input, self.weight * self.scale, bias=self.bias * self.lr_mul + ) + + return out + + def __repr__(self): + return ( + f"{self.__class__.__name__}({self.weight.shape[1]}, {self.weight.shape[0]})" + ) + + +class ModulatedConv2d(nn.Module): + def __init__( + self, + in_channel, + out_channel, + kernel_size, + style_dim, + demodulate=True, + upsample=False, + downsample=False, + blur_kernel=[1, 3, 3, 1], + fused=True, + ): + super().__init__() + + self.eps = 1e-8 + self.kernel_size = kernel_size + self.in_channel = in_channel + self.out_channel = out_channel + self.upsample = upsample + self.downsample = downsample + + if upsample: + factor = 2 + p = (len(blur_kernel) - factor) - (kernel_size - 1) + pad0 = (p + 1) // 2 + factor - 1 + pad1 = p // 2 + 1 + + self.blur = Blur(blur_kernel, pad=(pad0, pad1), upsample_factor=factor) + + if downsample: + factor = 2 + p = (len(blur_kernel) - factor) + (kernel_size - 1) + pad0 = (p + 1) // 2 + pad1 = p // 2 + + self.blur = Blur(blur_kernel, pad=(pad0, pad1)) + + fan_in = in_channel * kernel_size ** 2 + self.scale = 1 / math.sqrt(fan_in) + self.padding = kernel_size // 2 + + self.weight = nn.Parameter( + torch.randn(1, out_channel, in_channel, kernel_size, kernel_size) + ) + + self.modulation = EqualLinear(style_dim, in_channel, bias_init=1) + + self.demodulate = demodulate + self.fused = fused + + def __repr__(self): + return ( + f"{self.__class__.__name__}({self.in_channel}, {self.out_channel}, {self.kernel_size}, " + f"upsample={self.upsample}, downsample={self.downsample})" + ) + + def forward(self, input, style): + batch, in_channel, height, width = input.shape + + if not self.fused: + weight = self.scale * self.weight.squeeze(0) + style = self.modulation(style) + + if self.demodulate: + w = weight.unsqueeze(0) * style.view(batch, 1, in_channel, 1, 1) + dcoefs = (w.square().sum((2, 3, 4)) + 1e-8).rsqrt() + + input = input * style.reshape(batch, in_channel, 1, 1) + + if self.upsample: + weight = weight.transpose(0, 1) + out = conv2d_gradfix.conv_transpose2d( + input, weight, padding=0, stride=2 + ) + out = self.blur(out) + + elif self.downsample: + input = self.blur(input) + out = conv2d_gradfix.conv2d(input, weight, padding=0, stride=2) + + else: + out = conv2d_gradfix.conv2d(input, weight, padding=self.padding) + + if self.demodulate: + out = out * dcoefs.view(batch, -1, 1, 1) + + return out + + style = self.modulation(style).view(batch, 1, in_channel, 1, 1) + weight = self.scale * self.weight * style + + if self.demodulate: + demod = torch.rsqrt(weight.pow(2).sum([2, 3, 4]) + 1e-8) + weight = weight * demod.view(batch, self.out_channel, 1, 1, 1) + + weight = weight.view( + batch * self.out_channel, in_channel, self.kernel_size, self.kernel_size + ) + + if self.upsample: + input = input.view(1, batch * in_channel, height, width) + weight = weight.view( + batch, self.out_channel, in_channel, self.kernel_size, self.kernel_size + ) + weight = weight.transpose(1, 2).reshape( + batch * in_channel, self.out_channel, self.kernel_size, self.kernel_size + ) + out = conv2d_gradfix.conv_transpose2d( + input, weight, padding=0, stride=2, groups=batch + ) + _, _, height, width = out.shape + out = out.view(batch, self.out_channel, height, width) + out = self.blur(out) + + elif self.downsample: + input = self.blur(input) + _, _, height, width = input.shape + input = input.view(1, batch * in_channel, height, width) + out = conv2d_gradfix.conv2d( + input, weight, padding=0, stride=2, groups=batch + ) + _, _, height, width = out.shape + out = out.view(batch, self.out_channel, height, width) + + else: + input = input.view(1, batch * in_channel, height, width) + out = conv2d_gradfix.conv2d( + input, weight, padding=self.padding, groups=batch + ) + _, _, height, width = out.shape + out = out.view(batch, self.out_channel, height, width) + + return out + + +class NoiseInjection(nn.Module): + def __init__(self): + super().__init__() + + self.weight = nn.Parameter(torch.zeros(1)) + + def forward(self, image, noise=None): + if noise is None: + batch, _, height, width = image.shape + noise = image.new_empty(batch, 1, height, width).normal_() + + return image + self.weight * noise + + +class ConstantInput(nn.Module): + def __init__(self, channel, size=4): + super().__init__() + + self.input = nn.Parameter(torch.randn(1, channel, size, size)) + + def forward(self, input): + batch = input.shape[0] + out = self.input.repeat(batch, 1, 1, 1) + + return out + + +class StyledConv(nn.Module): + def __init__( + self, + in_channel, + out_channel, + kernel_size, + style_dim, + upsample=False, + blur_kernel=[1, 3, 3, 1], + demodulate=True, + ): + super().__init__() + + self.conv = ModulatedConv2d( + in_channel, + out_channel, + kernel_size, + style_dim, + upsample=upsample, + blur_kernel=blur_kernel, + demodulate=demodulate, + ) + + self.noise = NoiseInjection() + # self.bias = nn.Parameter(torch.zeros(1, out_channel, 1, 1)) + # self.activate = ScaledLeakyReLU(0.2) + self.activate = FusedLeakyReLU(out_channel) + + def forward(self, input, style, noise=None): + out = self.conv(input, style) + out = self.noise(out, noise=noise) + # out = out + self.bias + out = self.activate(out) + + return out + + +class ToRGB(nn.Module): + def __init__(self, in_channel, style_dim, upsample=True, blur_kernel=[1, 3, 3, 1]): + super().__init__() + + if upsample: + self.upsample = Upsample(blur_kernel) + + self.conv = ModulatedConv2d(in_channel, 3, 1, style_dim, demodulate=False) + self.bias = nn.Parameter(torch.zeros(1, 3, 1, 1)) + + def forward(self, input, style, skip=None): + out = self.conv(input, style) + out = out + self.bias + + if skip is not None: + skip = self.upsample(skip) + + out = out + skip + + return out + + +class Generator(nn.Module): + def __init__( + self, + size, + style_dim, + n_mlp, + channel_multiplier=2, + blur_kernel=[1, 3, 3, 1], + lr_mlp=0.01, + ): + super().__init__() + + self.size = size + + self.style_dim = style_dim + + layers = [PixelNorm()] + + for i in range(n_mlp): + layers.append( + EqualLinear( + style_dim, style_dim, lr_mul=lr_mlp, activation="fused_lrelu" + ) + ) + + self.style = nn.Sequential(*layers) + + self.channels = { + 4: 512, + 8: 512, + 16: 512, + 32: 512, + 64: 256 * channel_multiplier, + 128: 128 * channel_multiplier, + 256: 64 * channel_multiplier, + 512: 32 * channel_multiplier, + 1024: 16 * channel_multiplier, + } + + self.input = ConstantInput(self.channels[4]) + self.conv1 = StyledConv( + self.channels[4], self.channels[4], 3, style_dim, blur_kernel=blur_kernel + ) + self.to_rgb1 = ToRGB(self.channels[4], style_dim, upsample=False) + + self.log_size = int(math.log(size, 2))# 256, 8 + self.num_layers = (self.log_size - 2) * 2 + 1 + + self.convs = nn.ModuleList() + self.upsamples = nn.ModuleList() + self.to_rgbs = nn.ModuleList() + self.noises = nn.Module() + + in_channel = self.channels[4] + + for layer_idx in range(self.num_layers): + res = (layer_idx + 5) // 2 + shape = [1, 1, 2 ** res, 2 ** res] + self.noises.register_buffer(f"noise_{layer_idx}", torch.randn(*shape)) + + for i in range(3, self.log_size + 1): + out_channel = self.channels[2 ** i] + + self.convs.append( + StyledConv( + in_channel, + out_channel, + 3, + style_dim, + upsample=True, + blur_kernel=blur_kernel, + ) + ) + + self.convs.append( + StyledConv( + out_channel, out_channel, 3, style_dim, blur_kernel=blur_kernel + ) + ) + + self.to_rgbs.append(ToRGB(out_channel, style_dim)) + + in_channel = out_channel + + self.n_latent = self.log_size * 2 - 2 + + def make_noise(self): + device = self.input.input.device + + noises = [torch.randn(1, 1, 2 ** 2, 2 ** 2, device=device)] + + for i in range(3, self.log_size + 1): + for _ in range(2): + noises.append(torch.randn(1, 1, 2 ** i, 2 ** i, device=device)) + + return noises + + def mean_latent(self, n_latent): + latent_in = torch.randn( + n_latent, self.style_dim, device=self.input.input.device + ) + latent = self.style(latent_in).mean(0, keepdim=True) + + return latent + + def get_latent(self, input): + return self.style(input) + + def forward( + self, + styles, + return_latents=False, + inject_index=None, + truncation=1, + truncation_latent=None, + input_is_latent=False, + noise=None, + randomize_noise=True, + ): + if not input_is_latent: + styles = [self.style(s) for s in styles] + + if noise is None: + if randomize_noise: + noise = [None] * self.num_layers + else: + noise = [ + getattr(self.noises, f"noise_{i}") for i in range(self.num_layers) + ] + + if truncation < 1: + style_t = [] + + for style in styles: + style_t.append( + truncation_latent + truncation * (style - truncation_latent) + ) + + styles = style_t + + if len(styles) < 2: + inject_index = self.n_latent + + if styles[0].ndim < 3: + latent = styles[0].unsqueeze(1).repeat(1, inject_index, 1) + + else: + latent = styles[0] + + else: + if inject_index is None: + inject_index = random.randint(1, self.n_latent - 1) + + latent = styles[0].unsqueeze(1).repeat(1, inject_index, 1) + latent2 = styles[1].unsqueeze(1).repeat(1, self.n_latent - inject_index, 1) + + latent = torch.cat([latent, latent2], 1) + + out = self.input(latent) + out = self.conv1(out, latent[:, 0], noise=noise[0]) + + skip = self.to_rgb1(out, latent[:, 1]) + + i = 1 + for conv1, conv2, noise1, noise2, to_rgb in zip( + self.convs[::2], self.convs[1::2], noise[1::2], noise[2::2], self.to_rgbs + ): + out = conv1(out, latent[:, i], noise=noise1) + out = conv2(out, latent[:, i + 1], noise=noise2) + skip = to_rgb(out, latent[:, i + 2], skip) + + i += 2 + + image = skip + + if return_latents: + return image, latent + + else: + return image, None + + def clone(self): + """ + Create a copy of this model. + Returns: + model_copy (nn.Module) + """ + return copy.deepcopy(self) + +class StyleFusion(nn.Module): + def __init__(self, n_latent): + super().__init__() + self.n_latent = n_latent + self.weight = nn.Parameter(torch.zeros(n_latent)) + + def forward(self, sty1, sty2): + sty_t = sty1.clone() + for i in range(self.n_latent): + sty_t[:, i, :] = sty1[:, i, :]* self.weight[i] + sty2[:, i, :]* (1-self.weight[i]) + + return sty_t + + +class Generator_resty(nn.Module): + def __init__( + self, + size, + style_dim, + n_mlp, + channel_multiplier=2, + blur_kernel=[1, 3, 3, 1], + lr_mlp=0.01, + ): + super().__init__() + + self.size = size + self.style_dim = style_dim + + self.log_size = int(math.log(size, 2)) + self.num_layers = (self.log_size - 2) * 2 + 1 + self.n_latent = self.log_size * 2 - 2 + # add + self.fusion_style = StyleFusion(self.n_latent) + + layers = [PixelNorm()] + + # inject to w+, 14*512 + # for i in range(n_mlp): + # if i==n_mlp-1: + # layers.append( + # EqualLinear( + # style_dim, style_dim * self.n_latent, lr_mul=lr_mlp, activation="fused_lrelu" + # ) + # ) + # else: + # layers.append( + # EqualLinear( + # style_dim, style_dim, lr_mul=lr_mlp, activation="fused_lrelu" + # ) + # ) + + for i in range(n_mlp): + layers.append( + EqualLinear( + style_dim, style_dim, lr_mul=lr_mlp, activation="fused_lrelu" + ) + ) + layers.append( + EqualLinear( + style_dim, style_dim * self.n_latent, lr_mul=lr_mlp, activation="fused_lrelu" + ) + ) + + + self.style = nn.Sequential(*layers) + + self.channels = { + 4: 512, + 8: 512, + 16: 512, + 32: 512, + 64: 256 * channel_multiplier, + 128: 128 * channel_multiplier, + 256: 64 * channel_multiplier, + 512: 32 * channel_multiplier, + 1024: 16 * channel_multiplier, + } + + self.input = ConstantInput(self.channels[4]) + self.conv1 = StyledConv( + self.channels[4], self.channels[4], 3, style_dim, blur_kernel=blur_kernel + ) + self.to_rgb1 = ToRGB(self.channels[4], style_dim, upsample=False) + + + + self.convs = nn.ModuleList() + self.upsamples = nn.ModuleList() + self.to_rgbs = nn.ModuleList() + self.noises = nn.Module() + + in_channel = self.channels[4] + + for layer_idx in range(self.num_layers): + res = (layer_idx + 5) // 2 + shape = [1, 1, 2 ** res, 2 ** res] + self.noises.register_buffer(f"noise_{layer_idx}", torch.randn(*shape)) + + for i in range(3, self.log_size + 1): + out_channel = self.channels[2 ** i] + + self.convs.append( + StyledConv( + in_channel, + out_channel, + 3, + style_dim, + upsample=True, + blur_kernel=blur_kernel, + ) + ) + + self.convs.append( + StyledConv( + out_channel, out_channel, 3, style_dim, blur_kernel=blur_kernel + ) + ) + + self.to_rgbs.append(ToRGB(out_channel, style_dim)) + + in_channel = out_channel + + + + def make_noise(self): + device = self.input.input.device + + noises = [torch.randn(1, 1, 2 ** 2, 2 ** 2, device=device)] + + for i in range(3, self.log_size + 1): + for _ in range(2): + noises.append(torch.randn(1, 1, 2 ** i, 2 ** i, device=device)) + + return noises + + def mean_latent(self, n_latent): + latent_in = torch.randn( + n_latent, self.style_dim, device=self.input.input.device + ) + latent = self.style(latent_in).mean(0, keepdim=True) + + return latent + + def get_latent(self, input): + return self.style(input) + + def forward( + self, + styles, + style_single, + generator_source, + return_latents=False, + inject_index=None, + truncation=1, + truncation_latent=None, + input_is_latent=False, + noise=None, + randomize_noise=True, + ): + + styles = [generator_source.style(s) for s in styles] # [2,bs,512] or [1,bs,512] + if truncation < 1: + style_t = [] + for style in styles: + style_t.append( + truncation_latent + truncation * (style - truncation_latent) + ) + styles = style_t + + if len(styles) < 2: + inject_index = self.n_latent + if styles[0].ndim < 3: + source_styles = styles[0].unsqueeze(1).repeat(1, inject_index, 1) + else: + source_styles = styles[0] + else: + if inject_index is None: + inject_index = random.randint(1, self.n_latent - 1) + latent = styles[0].unsqueeze(1).repeat(1, inject_index, 1) + latent2 = styles[1].unsqueeze(1).repeat(1, self.n_latent - inject_index, 1) + source_styles = torch.cat([latent, latent2], 1) + + styles2 = self.style(style_single[0]) # bs*7068 + styles2 = styles2.view(-1, self.n_latent, 512) # bs*14*512 + + latent = self.fusion_style(styles2, source_styles) + # test + # latent = source_styles.clone() + + + + if noise is None: + if randomize_noise: + noise = [None] * self.num_layers + else: + noise = [ + getattr(self.noises, f"noise_{i}") for i in range(self.num_layers) + ] + + + + out = self.input(latent) + out = self.conv1(out, latent[:, 0], noise=noise[0]) + + skip = self.to_rgb1(out, latent[:, 1]) + + i = 1 + for conv1, conv2, noise1, noise2, to_rgb in zip( + self.convs[::2], self.convs[1::2], noise[1::2], noise[2::2], self.to_rgbs + ): + out = conv1(out, latent[:, i], noise=noise1) + out = conv2(out, latent[:, i + 1], noise=noise2) + skip = to_rgb(out, latent[:, i + 2], skip) + + i += 2 + + image = skip + + if return_latents: + return image, latent + + else: + return image, None + + def clone(self): + """ + Create a copy of this model. + Returns: + model_copy (nn.Module) + """ + return copy.deepcopy(self) + +class ConvLayer(nn.Sequential): + def __init__( + self, + in_channel, + out_channel, + kernel_size, + downsample=False, + blur_kernel=[1, 3, 3, 1], + bias=True, + activate=True, + ): + layers = [] + + if downsample: + factor = 2 + p = (len(blur_kernel) - factor) + (kernel_size - 1) + pad0 = (p + 1) // 2 + pad1 = p // 2 + + layers.append(Blur(blur_kernel, pad=(pad0, pad1))) + + stride = 2 + self.padding = 0 + + else: + stride = 1 + self.padding = kernel_size // 2 + + layers.append( + EqualConv2d( + in_channel, + out_channel, + kernel_size, + padding=self.padding, + stride=stride, + bias=bias and not activate, + ) + ) + + if activate: + layers.append(FusedLeakyReLU(out_channel, bias=bias)) + + super().__init__(*layers) + + +class ResBlock(nn.Module): + def __init__(self, in_channel, out_channel, blur_kernel=[1, 3, 3, 1]): + super().__init__() + + self.conv1 = ConvLayer(in_channel, in_channel, 3) + self.conv2 = ConvLayer(in_channel, out_channel, 3, downsample=True) + + self.skip = ConvLayer( + in_channel, out_channel, 1, downsample=True, activate=False, bias=False + ) + + def forward(self, input): + out = self.conv1(input) + out = self.conv2(out) + + skip = self.skip(input) + out = (out + skip) / math.sqrt(2) + + return out + + +class Discriminator(nn.Module): + def __init__(self, size, channel_multiplier=2, blur_kernel=[1, 3, 3, 1]): + super().__init__() + + channels = { + 4: 512, + 8: 512, + 16: 512, + 32: 512, + 64: 256 * channel_multiplier, + 128: 128 * channel_multiplier, + 256: 64 * channel_multiplier, + 512: 32 * channel_multiplier, + 1024: 16 * channel_multiplier, + } + + convs = [ConvLayer(3, channels[size], 1)] + + log_size = int(math.log(size, 2)) + + in_channel = channels[size] + + for i in range(log_size, 2, -1): + out_channel = channels[2 ** (i - 1)] + + convs.append(ResBlock(in_channel, out_channel, blur_kernel)) + + in_channel = out_channel + + self.convs = nn.Sequential(*convs) + + self.stddev_group = 4 + self.stddev_feat = 1 + + self.final_conv = ConvLayer(in_channel + 1, channels[4], 3) + self.final_linear = nn.Sequential( + EqualLinear(channels[4] * 4 * 4, channels[4], activation="fused_lrelu"), + EqualLinear(channels[4], 1), + ) + + def forward(self, input): + out = self.convs(input) + + batch, channel, height, width = out.shape + group = min(batch, self.stddev_group) + stddev = out.view( + group, -1, self.stddev_feat, channel // self.stddev_feat, height, width + ) + stddev = torch.sqrt(stddev.var(0, unbiased=False) + 1e-8) + stddev = stddev.mean([2, 3, 4], keepdims=True).squeeze(2) + stddev = stddev.repeat(group, 1, height, width) + out = torch.cat([out, stddev], 1) + + out = self.final_conv(out) + + out = out.view(batch, -1) + out = self.final_linear(out) + + return out + diff --git a/source/stylegan2/non_leaking.py b/source/stylegan2/non_leaking.py new file mode 100755 index 0000000..f44aac9 --- /dev/null +++ b/source/stylegan2/non_leaking.py @@ -0,0 +1,465 @@ +import math + +import torch +from torch import autograd +from torch.nn import functional as F +import numpy as np + +from distributed import reduce_sum +from op import upfirdn2d + + +class AdaptiveAugment: + def __init__(self, ada_aug_target, ada_aug_len, update_every, device): + self.ada_aug_target = ada_aug_target + self.ada_aug_len = ada_aug_len + self.update_every = update_every + + self.ada_update = 0 + self.ada_aug_buf = torch.tensor([0.0, 0.0], device=device) + self.r_t_stat = 0 + self.ada_aug_p = 0 + + @torch.no_grad() + def tune(self, real_pred): + self.ada_aug_buf += torch.tensor( + (torch.sign(real_pred).sum().item(), real_pred.shape[0]), + device=real_pred.device, + ) + self.ada_update += 1 + + if self.ada_update % self.update_every == 0: + self.ada_aug_buf = reduce_sum(self.ada_aug_buf) + pred_signs, n_pred = self.ada_aug_buf.tolist() + + self.r_t_stat = pred_signs / n_pred + + if self.r_t_stat > self.ada_aug_target: + sign = 1 + + else: + sign = -1 + + self.ada_aug_p += sign * n_pred / self.ada_aug_len + self.ada_aug_p = min(1, max(0, self.ada_aug_p)) + self.ada_aug_buf.mul_(0) + self.ada_update = 0 + + return self.ada_aug_p + + +SYM6 = ( + 0.015404109327027373, + 0.0034907120842174702, + -0.11799011114819057, + -0.048311742585633, + 0.4910559419267466, + 0.787641141030194, + 0.3379294217276218, + -0.07263752278646252, + -0.021060292512300564, + 0.04472490177066578, + 0.0017677118642428036, + -0.007800708325034148, +) + + +def translate_mat(t_x, t_y, device="cpu"): + batch = t_x.shape[0] + + mat = torch.eye(3, device=device).unsqueeze(0).repeat(batch, 1, 1) + translate = torch.stack((t_x, t_y), 1) + mat[:, :2, 2] = translate + + return mat + + +def rotate_mat(theta, device="cpu"): + batch = theta.shape[0] + + mat = torch.eye(3, device=device).unsqueeze(0).repeat(batch, 1, 1) + sin_t = torch.sin(theta) + cos_t = torch.cos(theta) + rot = torch.stack((cos_t, -sin_t, sin_t, cos_t), 1).view(batch, 2, 2) + mat[:, :2, :2] = rot + + return mat + + +def scale_mat(s_x, s_y, device="cpu"): + batch = s_x.shape[0] + + mat = torch.eye(3, device=device).unsqueeze(0).repeat(batch, 1, 1) + mat[:, 0, 0] = s_x + mat[:, 1, 1] = s_y + + return mat + + +def translate3d_mat(t_x, t_y, t_z): + batch = t_x.shape[0] + + mat = torch.eye(4).unsqueeze(0).repeat(batch, 1, 1) + translate = torch.stack((t_x, t_y, t_z), 1) + mat[:, :3, 3] = translate + + return mat + + +def rotate3d_mat(axis, theta): + batch = theta.shape[0] + + u_x, u_y, u_z = axis + + eye = torch.eye(3).unsqueeze(0) + cross = torch.tensor([(0, -u_z, u_y), (u_z, 0, -u_x), (-u_y, u_x, 0)]).unsqueeze(0) + outer = torch.tensor(axis) + outer = (outer.unsqueeze(1) * outer).unsqueeze(0) + + sin_t = torch.sin(theta).view(-1, 1, 1) + cos_t = torch.cos(theta).view(-1, 1, 1) + + rot = cos_t * eye + sin_t * cross + (1 - cos_t) * outer + + eye_4 = torch.eye(4).unsqueeze(0).repeat(batch, 1, 1) + eye_4[:, :3, :3] = rot + + return eye_4 + + +def scale3d_mat(s_x, s_y, s_z): + batch = s_x.shape[0] + + mat = torch.eye(4).unsqueeze(0).repeat(batch, 1, 1) + mat[:, 0, 0] = s_x + mat[:, 1, 1] = s_y + mat[:, 2, 2] = s_z + + return mat + + +def luma_flip_mat(axis, i): + batch = i.shape[0] + + eye = torch.eye(4).unsqueeze(0).repeat(batch, 1, 1) + axis = torch.tensor(axis + (0,)) + flip = 2 * torch.ger(axis, axis) * i.view(-1, 1, 1) + + return eye - flip + + +def saturation_mat(axis, i): + batch = i.shape[0] + + eye = torch.eye(4).unsqueeze(0).repeat(batch, 1, 1) + axis = torch.tensor(axis + (0,)) + axis = torch.ger(axis, axis) + saturate = axis + (eye - axis) * i.view(-1, 1, 1) + + return saturate + + +def lognormal_sample(size, mean=0, std=1, device="cpu"): + return torch.empty(size, device=device).log_normal_(mean=mean, std=std) + + +def category_sample(size, categories, device="cpu"): + category = torch.tensor(categories, device=device) + sample = torch.randint(high=len(categories), size=(size,), device=device) + + return category[sample] + + +def uniform_sample(size, low, high, device="cpu"): + return torch.empty(size, device=device).uniform_(low, high) + + +def normal_sample(size, mean=0, std=1, device="cpu"): + return torch.empty(size, device=device).normal_(mean, std) + + +def bernoulli_sample(size, p, device="cpu"): + return torch.empty(size, device=device).bernoulli_(p) + + +def random_mat_apply(p, transform, prev, eye, device="cpu"): + size = transform.shape[0] + select = bernoulli_sample(size, p, device=device).view(size, 1, 1) + select_transform = select * transform + (1 - select) * eye + + return select_transform @ prev + + +def sample_affine(p, size, height, width, device="cpu"): + G = torch.eye(3, device=device).unsqueeze(0).repeat(size, 1, 1) + eye = G + + # flip + param = category_sample(size, (0, 1)) + Gc = scale_mat(1 - 2.0 * param, torch.ones(size), device=device) + G = random_mat_apply(p, Gc, G, eye, device=device) + # print('flip', G, scale_mat(1 - 2.0 * param, torch.ones(size)), sep='\n') + + # 90 rotate + param = category_sample(size, (0, 3)) + Gc = rotate_mat(-math.pi / 2 * param, device=device) + G = random_mat_apply(p, Gc, G, eye, device=device) + # print('90 rotate', G, rotate_mat(-math.pi / 2 * param), sep='\n') + + # integer translate + param = uniform_sample(size, -0.125, 0.125) + param_height = torch.round(param * height) / height + param_width = torch.round(param * width) / width + Gc = translate_mat(param_width, param_height, device=device) + G = random_mat_apply(p, Gc, G, eye, device=device) + # print('integer translate', G, translate_mat(param_width, param_height), sep='\n') + + # isotropic scale + param = lognormal_sample(size, std=0.2 * math.log(2)) + Gc = scale_mat(param, param, device=device) + G = random_mat_apply(p, Gc, G, eye, device=device) + # print('isotropic scale', G, scale_mat(param, param), sep='\n') + + p_rot = 1 - math.sqrt(1 - p) + + # pre-rotate + param = uniform_sample(size, -math.pi, math.pi) + Gc = rotate_mat(-param, device=device) + G = random_mat_apply(p_rot, Gc, G, eye, device=device) + # print('pre-rotate', G, rotate_mat(-param), sep='\n') + + # anisotropic scale + param = lognormal_sample(size, std=0.2 * math.log(2)) + Gc = scale_mat(param, 1 / param, device=device) + G = random_mat_apply(p, Gc, G, eye, device=device) + # print('anisotropic scale', G, scale_mat(param, 1 / param), sep='\n') + + # post-rotate + param = uniform_sample(size, -math.pi, math.pi) + Gc = rotate_mat(-param, device=device) + G = random_mat_apply(p_rot, Gc, G, eye, device=device) + # print('post-rotate', G, rotate_mat(-param), sep='\n') + + # fractional translate + param = normal_sample(size, std=0.125) + Gc = translate_mat(param, param, device=device) + G = random_mat_apply(p, Gc, G, eye, device=device) + # print('fractional translate', G, translate_mat(param, param), sep='\n') + + return G + + +def sample_color(p, size): + C = torch.eye(4).unsqueeze(0).repeat(size, 1, 1) + eye = C + axis_val = 1 / math.sqrt(3) + axis = (axis_val, axis_val, axis_val) + + # brightness + param = normal_sample(size, std=0.2) + Cc = translate3d_mat(param, param, param) + C = random_mat_apply(p, Cc, C, eye) + + # contrast + param = lognormal_sample(size, std=0.5 * math.log(2)) + Cc = scale3d_mat(param, param, param) + C = random_mat_apply(p, Cc, C, eye) + + # luma flip + param = category_sample(size, (0, 1)) + Cc = luma_flip_mat(axis, param) + C = random_mat_apply(p, Cc, C, eye) + + # hue rotation + param = uniform_sample(size, -math.pi, math.pi) + Cc = rotate3d_mat(axis, param) + C = random_mat_apply(p, Cc, C, eye) + + # saturation + param = lognormal_sample(size, std=1 * math.log(2)) + Cc = saturation_mat(axis, param) + C = random_mat_apply(p, Cc, C, eye) + + return C + + +def make_grid(shape, x0, x1, y0, y1, device): + n, c, h, w = shape + grid = torch.empty(n, h, w, 3, device=device) + grid[:, :, :, 0] = torch.linspace(x0, x1, w, device=device) + grid[:, :, :, 1] = torch.linspace(y0, y1, h, device=device).unsqueeze(-1) + grid[:, :, :, 2] = 1 + + return grid + + +def affine_grid(grid, mat): + n, h, w, _ = grid.shape + return (grid.view(n, h * w, 3) @ mat.transpose(1, 2)).view(n, h, w, 2) + + +def get_padding(G, height, width, kernel_size): + device = G.device + + cx = (width - 1) / 2 + cy = (height - 1) / 2 + cp = torch.tensor( + [(-cx, -cy, 1), (cx, -cy, 1), (cx, cy, 1), (-cx, cy, 1)], device=device + ) + cp = G @ cp.T + + pad_k = kernel_size // 4 + + pad = cp[:, :2, :].permute(1, 0, 2).flatten(1) + pad = torch.cat((-pad, pad)).max(1).values + pad = pad + torch.tensor([pad_k * 2 - cx, pad_k * 2 - cy] * 2, device=device) + pad = pad.max(torch.tensor([0, 0] * 2, device=device)) + pad = pad.min(torch.tensor([width - 1, height - 1] * 2, device=device)) + + pad_x1, pad_y1, pad_x2, pad_y2 = pad.ceil().to(torch.int32) + + return pad_x1, pad_x2, pad_y1, pad_y2 + + +def try_sample_affine_and_pad(img, p, kernel_size, G=None): + batch, _, height, width = img.shape + + G_try = G + + if G is None: + G_try = torch.inverse(sample_affine(p, batch, height, width)) + + pad_x1, pad_x2, pad_y1, pad_y2 = get_padding(G_try, height, width, kernel_size) + + img_pad = F.pad(img, (pad_x1, pad_x2, pad_y1, pad_y2), mode="reflect") + + return img_pad, G_try, (pad_x1, pad_x2, pad_y1, pad_y2) + + +class GridSampleForward(autograd.Function): + @staticmethod + def forward(ctx, input, grid): + out = F.grid_sample( + input, grid, mode="bilinear", padding_mode="zeros", align_corners=False + ) + ctx.save_for_backward(input, grid) + + return out + + @staticmethod + def backward(ctx, grad_output): + input, grid = ctx.saved_tensors + grad_input, grad_grid = GridSampleBackward.apply(grad_output, input, grid) + + return grad_input, grad_grid + + +class GridSampleBackward(autograd.Function): + @staticmethod + def forward(ctx, grad_output, input, grid): + op = torch._C._jit_get_operation("aten::grid_sampler_2d_backward") + grad_input, grad_grid = op(grad_output, input, grid, 0, 0, False) + ctx.save_for_backward(grid) + + return grad_input, grad_grid + + @staticmethod + def backward(ctx, grad_grad_input, grad_grad_grid): + grid, = ctx.saved_tensors + grad_grad_output = None + + if ctx.needs_input_grad[0]: + grad_grad_output = GridSampleForward.apply(grad_grad_input, grid) + + return grad_grad_output, None, None + + +grid_sample = GridSampleForward.apply + + +def scale_mat_single(s_x, s_y): + return torch.tensor(((s_x, 0, 0), (0, s_y, 0), (0, 0, 1)), dtype=torch.float32) + + +def translate_mat_single(t_x, t_y): + return torch.tensor(((1, 0, t_x), (0, 1, t_y), (0, 0, 1)), dtype=torch.float32) + + +def random_apply_affine(img, p, G=None, antialiasing_kernel=SYM6): + kernel = antialiasing_kernel + len_k = len(kernel) + + kernel = torch.as_tensor(kernel).to(img) + # kernel = torch.ger(kernel, kernel).to(img) + kernel_flip = torch.flip(kernel, (0,)) + + img_pad, G, (pad_x1, pad_x2, pad_y1, pad_y2) = try_sample_affine_and_pad( + img, p, len_k, G + ) + + G_inv = ( + translate_mat_single((pad_x1 - pad_x2).item() / 2, (pad_y1 - pad_y2).item() / 2) + @ G + ) + up_pad = ( + (len_k + 2 - 1) // 2, + (len_k - 2) // 2, + (len_k + 2 - 1) // 2, + (len_k - 2) // 2, + ) + img_2x = upfirdn2d(img_pad, kernel.unsqueeze(0), up=(2, 1), pad=(*up_pad[:2], 0, 0)) + img_2x = upfirdn2d(img_2x, kernel.unsqueeze(1), up=(1, 2), pad=(0, 0, *up_pad[2:])) + G_inv = scale_mat_single(2, 2) @ G_inv @ scale_mat_single(1 / 2, 1 / 2) + G_inv = translate_mat_single(-0.5, -0.5) @ G_inv @ translate_mat_single(0.5, 0.5) + batch_size, channel, height, width = img.shape + pad_k = len_k // 4 + shape = (batch_size, channel, (height + pad_k * 2) * 2, (width + pad_k * 2) * 2) + G_inv = ( + scale_mat_single(2 / img_2x.shape[3], 2 / img_2x.shape[2]) + @ G_inv + @ scale_mat_single(1 / (2 / shape[3]), 1 / (2 / shape[2])) + ) + grid = F.affine_grid(G_inv[:, :2, :].to(img_2x), shape, align_corners=False) + img_affine = grid_sample(img_2x, grid) + d_p = -pad_k * 2 + down_pad = ( + d_p + (len_k - 2 + 1) // 2, + d_p + (len_k - 2) // 2, + d_p + (len_k - 2 + 1) // 2, + d_p + (len_k - 2) // 2, + ) + img_down = upfirdn2d( + img_affine, kernel_flip.unsqueeze(0), down=(2, 1), pad=(*down_pad[:2], 0, 0) + ) + img_down = upfirdn2d( + img_down, kernel_flip.unsqueeze(1), down=(1, 2), pad=(0, 0, *down_pad[2:]) + ) + + return img_down, G + + +def apply_color(img, mat): + batch = img.shape[0] + img = img.permute(0, 2, 3, 1) + mat_mul = mat[:, :3, :3].transpose(1, 2).view(batch, 1, 3, 3) + mat_add = mat[:, :3, 3].view(batch, 1, 1, 3) + img = img @ mat_mul + mat_add + img = img.permute(0, 3, 1, 2) + + return img + + +def random_apply_color(img, p, C=None): + if C is None: + C = sample_color(p, img.shape[0]) + + img = apply_color(img, C.to(img)) + + return img, C + + +def augment(img, p, transform_matrix=(None, None)): + img, G = random_apply_affine(img, p, transform_matrix[0]) + img, C = random_apply_color(img, p, transform_matrix[1]) + + return img, (G, C) diff --git a/source/stylegan2/op/__init__.py b/source/stylegan2/op/__init__.py new file mode 100755 index 0000000..d0918d9 --- /dev/null +++ b/source/stylegan2/op/__init__.py @@ -0,0 +1,2 @@ +from .fused_act import FusedLeakyReLU, fused_leaky_relu +from .upfirdn2d import upfirdn2d diff --git a/source/stylegan2/op/conv2d_gradfix.py b/source/stylegan2/op/conv2d_gradfix.py new file mode 100755 index 0000000..64229c5 --- /dev/null +++ b/source/stylegan2/op/conv2d_gradfix.py @@ -0,0 +1,227 @@ +import contextlib +import warnings + +import torch +from torch import autograd +from torch.nn import functional as F + +enabled = True +weight_gradients_disabled = False + + +@contextlib.contextmanager +def no_weight_gradients(): + global weight_gradients_disabled + + old = weight_gradients_disabled + weight_gradients_disabled = True + yield + weight_gradients_disabled = old + + +def conv2d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1): + if could_use_op(input): + return conv2d_gradfix( + transpose=False, + weight_shape=weight.shape, + stride=stride, + padding=padding, + output_padding=0, + dilation=dilation, + groups=groups, + ).apply(input, weight, bias) + + return F.conv2d( + input=input, + weight=weight, + bias=bias, + stride=stride, + padding=padding, + dilation=dilation, + groups=groups, + ) + + +def conv_transpose2d( + input, + weight, + bias=None, + stride=1, + padding=0, + output_padding=0, + groups=1, + dilation=1, +): + if could_use_op(input): + return conv2d_gradfix( + transpose=True, + weight_shape=weight.shape, + stride=stride, + padding=padding, + output_padding=output_padding, + groups=groups, + dilation=dilation, + ).apply(input, weight, bias) + + return F.conv_transpose2d( + input=input, + weight=weight, + bias=bias, + stride=stride, + padding=padding, + output_padding=output_padding, + dilation=dilation, + groups=groups, + ) + + +def could_use_op(input): + if (not enabled) or (not torch.backends.cudnn.enabled): + return False + + if input.device.type != "cuda": + return False + + if any(torch.__version__.startswith(x) for x in ["1.7.", "1.8."]): + return True + + warnings.warn( + f"conv2d_gradfix not supported on PyTorch {torch.__version__}. Falling back to torch.nn.functional.conv2d()." + ) + + return False + + +def ensure_tuple(xs, ndim): + xs = tuple(xs) if isinstance(xs, (tuple, list)) else (xs,) * ndim + + return xs + + +conv2d_gradfix_cache = dict() + + +def conv2d_gradfix( + transpose, weight_shape, stride, padding, output_padding, dilation, groups +): + ndim = 2 + weight_shape = tuple(weight_shape) + stride = ensure_tuple(stride, ndim) + padding = ensure_tuple(padding, ndim) + output_padding = ensure_tuple(output_padding, ndim) + dilation = ensure_tuple(dilation, ndim) + + key = (transpose, weight_shape, stride, padding, output_padding, dilation, groups) + if key in conv2d_gradfix_cache: + return conv2d_gradfix_cache[key] + + common_kwargs = dict( + stride=stride, padding=padding, dilation=dilation, groups=groups + ) + + def calc_output_padding(input_shape, output_shape): + if transpose: + return [0, 0] + + return [ + input_shape[i + 2] + - (output_shape[i + 2] - 1) * stride[i] + - (1 - 2 * padding[i]) + - dilation[i] * (weight_shape[i + 2] - 1) + for i in range(ndim) + ] + + class Conv2d(autograd.Function): + @staticmethod + def forward(ctx, input, weight, bias): + if not transpose: + out = F.conv2d(input=input, weight=weight, bias=bias, **common_kwargs) + + else: + out = F.conv_transpose2d( + input=input, + weight=weight, + bias=bias, + output_padding=output_padding, + **common_kwargs, + ) + + ctx.save_for_backward(input, weight) + + return out + + @staticmethod + def backward(ctx, grad_output): + input, weight = ctx.saved_tensors + grad_input, grad_weight, grad_bias = None, None, None + + if ctx.needs_input_grad[0]: + p = calc_output_padding( + input_shape=input.shape, output_shape=grad_output.shape + ) + grad_input = conv2d_gradfix( + transpose=(not transpose), + weight_shape=weight_shape, + output_padding=p, + **common_kwargs, + ).apply(grad_output, weight, None) + + if ctx.needs_input_grad[1] and not weight_gradients_disabled: + grad_weight = Conv2dGradWeight.apply(grad_output, input) + + if ctx.needs_input_grad[2]: + grad_bias = grad_output.sum((0, 2, 3)) + + return grad_input, grad_weight, grad_bias + + class Conv2dGradWeight(autograd.Function): + @staticmethod + def forward(ctx, grad_output, input): + op = torch._C._jit_get_operation( + "aten::cudnn_convolution_backward_weight" + if not transpose + else "aten::cudnn_convolution_transpose_backward_weight" + ) + flags = [ + torch.backends.cudnn.benchmark, + torch.backends.cudnn.deterministic, + torch.backends.cudnn.allow_tf32, + ] + grad_weight = op( + weight_shape, + grad_output, + input, + padding, + stride, + dilation, + groups, + *flags, + ) + ctx.save_for_backward(grad_output, input) + + return grad_weight + + @staticmethod + def backward(ctx, grad_grad_weight): + grad_output, input = ctx.saved_tensors + grad_grad_output, grad_grad_input = None, None + + if ctx.needs_input_grad[0]: + grad_grad_output = Conv2d.apply(input, grad_grad_weight, None) + + if ctx.needs_input_grad[1]: + p = calc_output_padding( + input_shape=input.shape, output_shape=grad_output.shape + ) + grad_grad_input = conv2d_gradfix( + transpose=(not transpose), + weight_shape=weight_shape, + output_padding=p, + **common_kwargs, + ).apply(grad_output, grad_grad_weight, None) + + return grad_grad_output, grad_grad_input + + conv2d_gradfix_cache[key] = Conv2d + + return Conv2d diff --git a/source/stylegan2/op/fused_act.py b/source/stylegan2/op/fused_act.py new file mode 100755 index 0000000..3331641 --- /dev/null +++ b/source/stylegan2/op/fused_act.py @@ -0,0 +1,119 @@ +import os + +import torch +from torch import nn +from torch.nn import functional as F +from torch.autograd import Function +from torch.utils.cpp_extension import load + + +module_path = os.path.dirname(__file__) +fused = load( + "fused", + sources=[ + os.path.join(module_path, "fused_bias_act.cpp"), + os.path.join(module_path, "fused_bias_act_kernel.cu"), + ], +) + + +class FusedLeakyReLUFunctionBackward(Function): + @staticmethod + def forward(ctx, grad_output, out, bias, negative_slope, scale): + ctx.save_for_backward(out) + ctx.negative_slope = negative_slope + ctx.scale = scale + + empty = grad_output.new_empty(0) + + grad_input = fused.fused_bias_act( + grad_output.contiguous(), empty, out, 3, 1, negative_slope, scale + ) + + dim = [0] + + if grad_input.ndim > 2: + dim += list(range(2, grad_input.ndim)) + + if bias: + grad_bias = grad_input.sum(dim).detach() + + else: + grad_bias = empty + + return grad_input, grad_bias + + @staticmethod + def backward(ctx, gradgrad_input, gradgrad_bias): + out, = ctx.saved_tensors + gradgrad_out = fused.fused_bias_act( + gradgrad_input, gradgrad_bias, out, 3, 1, ctx.negative_slope, ctx.scale + ) + + return gradgrad_out, None, None, None, None + + +class FusedLeakyReLUFunction(Function): + @staticmethod + def forward(ctx, input, bias, negative_slope, scale): + empty = input.new_empty(0) + + ctx.bias = bias is not None + + if bias is None: + bias = empty + + out = fused.fused_bias_act(input, bias, empty, 3, 0, negative_slope, scale) + ctx.save_for_backward(out) + ctx.negative_slope = negative_slope + ctx.scale = scale + + return out + + @staticmethod + def backward(ctx, grad_output): + out, = ctx.saved_tensors + + grad_input, grad_bias = FusedLeakyReLUFunctionBackward.apply( + grad_output, out, ctx.bias, ctx.negative_slope, ctx.scale + ) + + if not ctx.bias: + grad_bias = None + + return grad_input, grad_bias, None, None + + +class FusedLeakyReLU(nn.Module): + def __init__(self, channel, bias=True, negative_slope=0.2, scale=2 ** 0.5): + super().__init__() + + if bias: + self.bias = nn.Parameter(torch.zeros(channel)) + + else: + self.bias = None + + self.negative_slope = negative_slope + self.scale = scale + + def forward(self, input): + return fused_leaky_relu(input, self.bias, self.negative_slope, self.scale) + + +def fused_leaky_relu(input, bias=None, negative_slope=0.2, scale=2 ** 0.5): + if input.device.type == "cpu": + if bias is not None: + rest_dim = [1] * (input.ndim - bias.ndim - 1) + return ( + F.leaky_relu( + input + bias.view(1, bias.shape[0], *rest_dim), negative_slope=0.2 + ) + * scale + ) + + else: + return F.leaky_relu(input, negative_slope=0.2) * scale + + else: + return FusedLeakyReLUFunction.apply(input, bias, negative_slope, scale) diff --git a/source/stylegan2/op/fused_bias_act.cpp b/source/stylegan2/op/fused_bias_act.cpp new file mode 100755 index 0000000..e8466aa --- /dev/null +++ b/source/stylegan2/op/fused_bias_act.cpp @@ -0,0 +1,32 @@ + +#include +#include + +torch::Tensor fused_bias_act_op(const torch::Tensor &input, + const torch::Tensor &bias, + const torch::Tensor &refer, int act, int grad, + float alpha, float scale); + +#define CHECK_CUDA(x) \ + TORCH_CHECK(x.type().is_cuda(), #x " must be a CUDA tensor") +#define CHECK_CONTIGUOUS(x) \ + TORCH_CHECK(x.is_contiguous(), #x " must be contiguous") +#define CHECK_INPUT(x) \ + CHECK_CUDA(x); \ + CHECK_CONTIGUOUS(x) + +torch::Tensor fused_bias_act(const torch::Tensor &input, + const torch::Tensor &bias, + const torch::Tensor &refer, int act, int grad, + float alpha, float scale) { + CHECK_INPUT(input); + CHECK_INPUT(bias); + + at::DeviceGuard guard(input.device()); + + return fused_bias_act_op(input, bias, refer, act, grad, alpha, scale); +} + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + m.def("fused_bias_act", &fused_bias_act, "fused bias act (CUDA)"); +} \ No newline at end of file diff --git a/source/stylegan2/op/fused_bias_act_kernel.cu b/source/stylegan2/op/fused_bias_act_kernel.cu new file mode 100755 index 0000000..65427d3 --- /dev/null +++ b/source/stylegan2/op/fused_bias_act_kernel.cu @@ -0,0 +1,105 @@ +// 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 + +#include + +#include +#include +#include +#include + + +#include +#include + +template +static __global__ void +fused_bias_act_kernel(scalar_t *out, const scalar_t *p_x, const scalar_t *p_b, + const scalar_t *p_ref, int act, int grad, scalar_t alpha, + scalar_t scale, int loop_x, int size_x, int step_b, + int size_b, int use_bias, int use_ref) { + int xi = blockIdx.x * loop_x * blockDim.x + threadIdx.x; + + scalar_t zero = 0.0; + + for (int loop_idx = 0; loop_idx < loop_x && xi < size_x; + loop_idx++, xi += blockDim.x) { + scalar_t x = p_x[xi]; + + if (use_bias) { + x += p_b[(xi / step_b) % size_b]; + } + + scalar_t ref = use_ref ? p_ref[xi] : zero; + + scalar_t y; + + switch (act * 10 + grad) { + default: + case 10: + y = x; + break; + case 11: + y = x; + break; + case 12: + y = 0.0; + break; + + case 30: + y = (x > 0.0) ? x : x * alpha; + break; + case 31: + y = (ref > 0.0) ? x : x * alpha; + break; + case 32: + y = 0.0; + break; + } + + out[xi] = y * scale; + } +} + +torch::Tensor fused_bias_act_op(const torch::Tensor &input, + const torch::Tensor &bias, + const torch::Tensor &refer, int act, int grad, + float alpha, float scale) { + int curDevice = -1; + cudaGetDevice(&curDevice); + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + auto x = input.contiguous(); + auto b = bias.contiguous(); + auto ref = refer.contiguous(); + + int use_bias = b.numel() ? 1 : 0; + int use_ref = ref.numel() ? 1 : 0; + + int size_x = x.numel(); + int size_b = b.numel(); + int step_b = 1; + + for (int i = 1 + 1; i < x.dim(); i++) { + step_b *= x.size(i); + } + + int loop_x = 4; + int block_size = 4 * 32; + int grid_size = (size_x - 1) / (loop_x * block_size) + 1; + + auto y = torch::empty_like(x); + + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + x.scalar_type(), "fused_bias_act_kernel", [&] { + fused_bias_act_kernel<<>>( + y.data_ptr(), x.data_ptr(), + b.data_ptr(), ref.data_ptr(), act, grad, alpha, + scale, loop_x, size_x, step_b, size_b, use_bias, use_ref); + }); + + return y; +} \ No newline at end of file diff --git a/source/stylegan2/op/upfirdn2d.cpp b/source/stylegan2/op/upfirdn2d.cpp new file mode 100755 index 0000000..d667b2c --- /dev/null +++ b/source/stylegan2/op/upfirdn2d.cpp @@ -0,0 +1,31 @@ +#include +#include + +torch::Tensor upfirdn2d_op(const torch::Tensor &input, + const torch::Tensor &kernel, int up_x, int up_y, + int down_x, int down_y, int pad_x0, int pad_x1, + int pad_y0, int pad_y1); + +#define CHECK_CUDA(x) \ + TORCH_CHECK(x.type().is_cuda(), #x " must be a CUDA tensor") +#define CHECK_CONTIGUOUS(x) \ + TORCH_CHECK(x.is_contiguous(), #x " must be contiguous") +#define CHECK_INPUT(x) \ + CHECK_CUDA(x); \ + CHECK_CONTIGUOUS(x) + +torch::Tensor upfirdn2d(const torch::Tensor &input, const torch::Tensor &kernel, + int up_x, int up_y, int down_x, int down_y, int pad_x0, + int pad_x1, int pad_y0, int pad_y1) { + CHECK_INPUT(input); + CHECK_INPUT(kernel); + + at::DeviceGuard guard(input.device()); + + return upfirdn2d_op(input, kernel, up_x, up_y, down_x, down_y, pad_x0, pad_x1, + pad_y0, pad_y1); +} + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + m.def("upfirdn2d", &upfirdn2d, "upfirdn2d (CUDA)"); +} \ No newline at end of file diff --git a/source/stylegan2/op/upfirdn2d.py b/source/stylegan2/op/upfirdn2d.py new file mode 100755 index 0000000..67e0375 --- /dev/null +++ b/source/stylegan2/op/upfirdn2d.py @@ -0,0 +1,209 @@ +from collections import abc +import os + +import torch +from torch.nn import functional as F +from torch.autograd import Function +from torch.utils.cpp_extension import load + + +module_path = os.path.dirname(__file__) +upfirdn2d_op = load( + "upfirdn2d", + sources=[ + os.path.join(module_path, "upfirdn2d.cpp"), + os.path.join(module_path, "upfirdn2d_kernel.cu"), + ], +) + + +class UpFirDn2dBackward(Function): + @staticmethod + def forward( + ctx, grad_output, kernel, grad_kernel, up, down, pad, g_pad, in_size, out_size + ): + + up_x, up_y = up + down_x, down_y = down + g_pad_x0, g_pad_x1, g_pad_y0, g_pad_y1 = g_pad + + grad_output = grad_output.reshape(-1, out_size[0], out_size[1], 1) + + grad_input = upfirdn2d_op.upfirdn2d( + grad_output, + grad_kernel, + down_x, + down_y, + up_x, + up_y, + g_pad_x0, + g_pad_x1, + g_pad_y0, + g_pad_y1, + ) + grad_input = grad_input.view(in_size[0], in_size[1], in_size[2], in_size[3]) + + ctx.save_for_backward(kernel) + + pad_x0, pad_x1, pad_y0, pad_y1 = pad + + ctx.up_x = up_x + ctx.up_y = up_y + ctx.down_x = down_x + ctx.down_y = down_y + ctx.pad_x0 = pad_x0 + ctx.pad_x1 = pad_x1 + ctx.pad_y0 = pad_y0 + ctx.pad_y1 = pad_y1 + ctx.in_size = in_size + ctx.out_size = out_size + + return grad_input + + @staticmethod + def backward(ctx, gradgrad_input): + kernel, = ctx.saved_tensors + + gradgrad_input = gradgrad_input.reshape(-1, ctx.in_size[2], ctx.in_size[3], 1) + + gradgrad_out = upfirdn2d_op.upfirdn2d( + gradgrad_input, + kernel, + ctx.up_x, + ctx.up_y, + ctx.down_x, + ctx.down_y, + ctx.pad_x0, + ctx.pad_x1, + ctx.pad_y0, + ctx.pad_y1, + ) + # gradgrad_out = gradgrad_out.view(ctx.in_size[0], ctx.out_size[0], ctx.out_size[1], ctx.in_size[3]) + gradgrad_out = gradgrad_out.view( + ctx.in_size[0], ctx.in_size[1], ctx.out_size[0], ctx.out_size[1] + ) + + return gradgrad_out, None, None, None, None, None, None, None, None + + +class UpFirDn2d(Function): + @staticmethod + def forward(ctx, input, kernel, up, down, pad): + up_x, up_y = up + down_x, down_y = down + pad_x0, pad_x1, pad_y0, pad_y1 = pad + + kernel_h, kernel_w = kernel.shape + batch, channel, in_h, in_w = input.shape + ctx.in_size = input.shape + + input = input.reshape(-1, in_h, in_w, 1) + + ctx.save_for_backward(kernel, torch.flip(kernel, [0, 1])) + + out_h = (in_h * up_y + pad_y0 + pad_y1 - kernel_h + down_y) // down_y + out_w = (in_w * up_x + pad_x0 + pad_x1 - kernel_w + down_x) // down_x + ctx.out_size = (out_h, out_w) + + ctx.up = (up_x, up_y) + ctx.down = (down_x, down_y) + ctx.pad = (pad_x0, pad_x1, pad_y0, pad_y1) + + g_pad_x0 = kernel_w - pad_x0 - 1 + g_pad_y0 = kernel_h - pad_y0 - 1 + g_pad_x1 = in_w * up_x - out_w * down_x + pad_x0 - up_x + 1 + g_pad_y1 = in_h * up_y - out_h * down_y + pad_y0 - up_y + 1 + + ctx.g_pad = (g_pad_x0, g_pad_x1, g_pad_y0, g_pad_y1) + + out = upfirdn2d_op.upfirdn2d( + input, kernel, up_x, up_y, down_x, down_y, pad_x0, pad_x1, pad_y0, pad_y1 + ) + # out = out.view(major, out_h, out_w, minor) + out = out.view(-1, channel, out_h, out_w) + + return out + + @staticmethod + def backward(ctx, grad_output): + kernel, grad_kernel = ctx.saved_tensors + + grad_input = None + + if ctx.needs_input_grad[0]: + grad_input = UpFirDn2dBackward.apply( + grad_output, + kernel, + grad_kernel, + ctx.up, + ctx.down, + ctx.pad, + ctx.g_pad, + ctx.in_size, + ctx.out_size, + ) + + return grad_input, None, None, None, None + + +def upfirdn2d(input, kernel, up=1, down=1, pad=(0, 0)): + if not isinstance(up, abc.Iterable): + up = (up, up) + + if not isinstance(down, abc.Iterable): + down = (down, down) + + if len(pad) == 2: + pad = (pad[0], pad[1], pad[0], pad[1]) + + if input.device.type == "cpu": + out = upfirdn2d_native(input, kernel, *up, *down, *pad) + + else: + out = UpFirDn2d.apply(input, kernel, up, down, pad) + + return out + + +def upfirdn2d_native( + input, kernel, up_x, up_y, down_x, down_y, pad_x0, pad_x1, pad_y0, pad_y1 +): + _, channel, in_h, in_w = input.shape + input = input.reshape(-1, in_h, in_w, 1) + + _, in_h, in_w, minor = input.shape + kernel_h, kernel_w = kernel.shape + + out = input.view(-1, in_h, 1, in_w, 1, minor) + out = F.pad(out, [0, 0, 0, up_x - 1, 0, 0, 0, up_y - 1]) + out = out.view(-1, in_h * up_y, in_w * up_x, minor) + + out = F.pad( + out, [0, 0, max(pad_x0, 0), max(pad_x1, 0), max(pad_y0, 0), max(pad_y1, 0)] + ) + out = out[ + :, + max(-pad_y0, 0) : out.shape[1] - max(-pad_y1, 0), + max(-pad_x0, 0) : out.shape[2] - max(-pad_x1, 0), + :, + ] + + out = out.permute(0, 3, 1, 2) + out = out.reshape( + [-1, 1, in_h * up_y + pad_y0 + pad_y1, in_w * up_x + pad_x0 + pad_x1] + ) + w = torch.flip(kernel, [0, 1]).view(1, 1, kernel_h, kernel_w) + out = F.conv2d(out, w) + out = out.reshape( + -1, + minor, + in_h * up_y + pad_y0 + pad_y1 - kernel_h + 1, + in_w * up_x + pad_x0 + pad_x1 - kernel_w + 1, + ) + out = out.permute(0, 2, 3, 1) + out = out[:, ::down_y, ::down_x, :] + + out_h = (in_h * up_y + pad_y0 + pad_y1 - kernel_h + down_y) // down_y + out_w = (in_w * up_x + pad_x0 + pad_x1 - kernel_w + down_x) // down_x + + return out.view(-1, channel, out_h, out_w) diff --git a/source/stylegan2/op/upfirdn2d_kernel.cu b/source/stylegan2/op/upfirdn2d_kernel.cu new file mode 100755 index 0000000..61d3dc4 --- /dev/null +++ b/source/stylegan2/op/upfirdn2d_kernel.cu @@ -0,0 +1,369 @@ +// 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 + +#include + +#include +#include +#include +#include + +#include +#include + +static __host__ __device__ __forceinline__ int floor_div(int a, int b) { + int c = a / b; + + if (c * b > a) { + c--; + } + + return c; +} + +struct UpFirDn2DKernelParams { + int up_x; + int up_y; + int down_x; + int down_y; + int pad_x0; + int pad_x1; + int pad_y0; + int pad_y1; + + int major_dim; + int in_h; + int in_w; + int minor_dim; + int kernel_h; + int kernel_w; + int out_h; + int out_w; + int loop_major; + int loop_x; +}; + +template +__global__ void upfirdn2d_kernel_large(scalar_t *out, const scalar_t *input, + const scalar_t *kernel, + const UpFirDn2DKernelParams p) { + int minor_idx = blockIdx.x * blockDim.x + threadIdx.x; + int out_y = minor_idx / p.minor_dim; + minor_idx -= out_y * p.minor_dim; + int out_x_base = blockIdx.y * p.loop_x * blockDim.y + threadIdx.y; + int major_idx_base = blockIdx.z * p.loop_major; + + if (out_x_base >= p.out_w || out_y >= p.out_h || + major_idx_base >= p.major_dim) { + return; + } + + int mid_y = out_y * p.down_y + p.up_y - 1 - p.pad_y0; + int in_y = min(max(floor_div(mid_y, p.up_y), 0), p.in_h); + int h = min(max(floor_div(mid_y + p.kernel_h, p.up_y), 0), p.in_h) - in_y; + int kernel_y = mid_y + p.kernel_h - (in_y + 1) * p.up_y; + + for (int loop_major = 0, major_idx = major_idx_base; + loop_major < p.loop_major && major_idx < p.major_dim; + loop_major++, major_idx++) { + for (int loop_x = 0, out_x = out_x_base; + loop_x < p.loop_x && out_x < p.out_w; loop_x++, out_x += blockDim.y) { + int mid_x = out_x * p.down_x + p.up_x - 1 - p.pad_x0; + int in_x = min(max(floor_div(mid_x, p.up_x), 0), p.in_w); + int w = min(max(floor_div(mid_x + p.kernel_w, p.up_x), 0), p.in_w) - in_x; + int kernel_x = mid_x + p.kernel_w - (in_x + 1) * p.up_x; + + const scalar_t *x_p = + &input[((major_idx * p.in_h + in_y) * p.in_w + in_x) * p.minor_dim + + minor_idx]; + const scalar_t *k_p = &kernel[kernel_y * p.kernel_w + kernel_x]; + int x_px = p.minor_dim; + int k_px = -p.up_x; + int x_py = p.in_w * p.minor_dim; + int k_py = -p.up_y * p.kernel_w; + + scalar_t v = 0.0f; + + for (int y = 0; y < h; y++) { + for (int x = 0; x < w; x++) { + v += static_cast(*x_p) * static_cast(*k_p); + x_p += x_px; + k_p += k_px; + } + + x_p += x_py - w * x_px; + k_p += k_py - w * k_px; + } + + out[((major_idx * p.out_h + out_y) * p.out_w + out_x) * p.minor_dim + + minor_idx] = v; + } + } +} + +template +__global__ void upfirdn2d_kernel(scalar_t *out, const scalar_t *input, + const scalar_t *kernel, + const UpFirDn2DKernelParams p) { + const int tile_in_h = ((tile_out_h - 1) * down_y + kernel_h - 1) / up_y + 1; + const int tile_in_w = ((tile_out_w - 1) * down_x + kernel_w - 1) / up_x + 1; + + __shared__ volatile float sk[kernel_h][kernel_w]; + __shared__ volatile float sx[tile_in_h][tile_in_w]; + + int minor_idx = blockIdx.x; + int tile_out_y = minor_idx / p.minor_dim; + minor_idx -= tile_out_y * p.minor_dim; + tile_out_y *= tile_out_h; + int tile_out_x_base = blockIdx.y * p.loop_x * tile_out_w; + int major_idx_base = blockIdx.z * p.loop_major; + + if (tile_out_x_base >= p.out_w | tile_out_y >= p.out_h | + major_idx_base >= p.major_dim) { + return; + } + + for (int tap_idx = threadIdx.x; tap_idx < kernel_h * kernel_w; + tap_idx += blockDim.x) { + int ky = tap_idx / kernel_w; + int kx = tap_idx - ky * kernel_w; + scalar_t v = 0.0; + + if (kx < p.kernel_w & ky < p.kernel_h) { + v = kernel[(p.kernel_h - 1 - ky) * p.kernel_w + (p.kernel_w - 1 - kx)]; + } + + sk[ky][kx] = v; + } + + for (int loop_major = 0, major_idx = major_idx_base; + loop_major < p.loop_major & major_idx < p.major_dim; + loop_major++, major_idx++) { + for (int loop_x = 0, tile_out_x = tile_out_x_base; + loop_x < p.loop_x & tile_out_x < p.out_w; + loop_x++, tile_out_x += tile_out_w) { + int tile_mid_x = tile_out_x * down_x + up_x - 1 - p.pad_x0; + int tile_mid_y = tile_out_y * down_y + up_y - 1 - p.pad_y0; + int tile_in_x = floor_div(tile_mid_x, up_x); + int tile_in_y = floor_div(tile_mid_y, up_y); + + __syncthreads(); + + for (int in_idx = threadIdx.x; in_idx < tile_in_h * tile_in_w; + in_idx += blockDim.x) { + int rel_in_y = in_idx / tile_in_w; + int rel_in_x = in_idx - rel_in_y * tile_in_w; + int in_x = rel_in_x + tile_in_x; + int in_y = rel_in_y + tile_in_y; + + scalar_t v = 0.0; + + if (in_x >= 0 & in_y >= 0 & in_x < p.in_w & in_y < p.in_h) { + v = input[((major_idx * p.in_h + in_y) * p.in_w + in_x) * + p.minor_dim + + minor_idx]; + } + + sx[rel_in_y][rel_in_x] = v; + } + + __syncthreads(); + for (int out_idx = threadIdx.x; out_idx < tile_out_h * tile_out_w; + out_idx += blockDim.x) { + int rel_out_y = out_idx / tile_out_w; + int rel_out_x = out_idx - rel_out_y * tile_out_w; + int out_x = rel_out_x + tile_out_x; + int out_y = rel_out_y + tile_out_y; + + int mid_x = tile_mid_x + rel_out_x * down_x; + int mid_y = tile_mid_y + rel_out_y * down_y; + int in_x = floor_div(mid_x, up_x); + int in_y = floor_div(mid_y, up_y); + int rel_in_x = in_x - tile_in_x; + int rel_in_y = in_y - tile_in_y; + int kernel_x = (in_x + 1) * up_x - mid_x - 1; + int kernel_y = (in_y + 1) * up_y - mid_y - 1; + + scalar_t v = 0.0; + +#pragma unroll + for (int y = 0; y < kernel_h / up_y; y++) +#pragma unroll + for (int x = 0; x < kernel_w / up_x; x++) + v += sx[rel_in_y + y][rel_in_x + x] * + sk[kernel_y + y * up_y][kernel_x + x * up_x]; + + if (out_x < p.out_w & out_y < p.out_h) { + out[((major_idx * p.out_h + out_y) * p.out_w + out_x) * p.minor_dim + + minor_idx] = v; + } + } + } + } +} + +torch::Tensor upfirdn2d_op(const torch::Tensor &input, + const torch::Tensor &kernel, int up_x, int up_y, + int down_x, int down_y, int pad_x0, int pad_x1, + int pad_y0, int pad_y1) { + int curDevice = -1; + cudaGetDevice(&curDevice); + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + UpFirDn2DKernelParams p; + + auto x = input.contiguous(); + auto k = kernel.contiguous(); + + p.major_dim = x.size(0); + p.in_h = x.size(1); + p.in_w = x.size(2); + p.minor_dim = x.size(3); + p.kernel_h = k.size(0); + p.kernel_w = k.size(1); + p.up_x = up_x; + p.up_y = up_y; + p.down_x = down_x; + p.down_y = down_y; + p.pad_x0 = pad_x0; + p.pad_x1 = pad_x1; + p.pad_y0 = pad_y0; + p.pad_y1 = pad_y1; + + p.out_h = (p.in_h * p.up_y + p.pad_y0 + p.pad_y1 - p.kernel_h + p.down_y) / + p.down_y; + p.out_w = (p.in_w * p.up_x + p.pad_x0 + p.pad_x1 - p.kernel_w + p.down_x) / + p.down_x; + + auto out = + at::empty({p.major_dim, p.out_h, p.out_w, p.minor_dim}, x.options()); + + int mode = -1; + + int tile_out_h = -1; + int tile_out_w = -1; + + if (p.up_x == 1 && p.up_y == 1 && p.down_x == 1 && p.down_y == 1 && + p.kernel_h <= 4 && p.kernel_w <= 4) { + mode = 1; + tile_out_h = 16; + tile_out_w = 64; + } + + if (p.up_x == 1 && p.up_y == 1 && p.down_x == 1 && p.down_y == 1 && + p.kernel_h <= 3 && p.kernel_w <= 3) { + mode = 2; + tile_out_h = 16; + tile_out_w = 64; + } + + if (p.up_x == 2 && p.up_y == 2 && p.down_x == 1 && p.down_y == 1 && + p.kernel_h <= 4 && p.kernel_w <= 4) { + mode = 3; + tile_out_h = 16; + tile_out_w = 64; + } + + if (p.up_x == 2 && p.up_y == 2 && p.down_x == 1 && p.down_y == 1 && + p.kernel_h <= 2 && p.kernel_w <= 2) { + mode = 4; + tile_out_h = 16; + tile_out_w = 64; + } + + if (p.up_x == 1 && p.up_y == 1 && p.down_x == 2 && p.down_y == 2 && + p.kernel_h <= 4 && p.kernel_w <= 4) { + mode = 5; + tile_out_h = 8; + tile_out_w = 32; + } + + if (p.up_x == 1 && p.up_y == 1 && p.down_x == 2 && p.down_y == 2 && + p.kernel_h <= 2 && p.kernel_w <= 2) { + mode = 6; + tile_out_h = 8; + tile_out_w = 32; + } + + dim3 block_size; + dim3 grid_size; + + if (tile_out_h > 0 && tile_out_w > 0) { + p.loop_major = (p.major_dim - 1) / 16384 + 1; + p.loop_x = 1; + block_size = dim3(32 * 8, 1, 1); + grid_size = dim3(((p.out_h - 1) / tile_out_h + 1) * p.minor_dim, + (p.out_w - 1) / (p.loop_x * tile_out_w) + 1, + (p.major_dim - 1) / p.loop_major + 1); + } else { + p.loop_major = (p.major_dim - 1) / 16384 + 1; + p.loop_x = 4; + block_size = dim3(4, 32, 1); + grid_size = dim3((p.out_h * p.minor_dim - 1) / block_size.x + 1, + (p.out_w - 1) / (p.loop_x * block_size.y) + 1, + (p.major_dim - 1) / p.loop_major + 1); + } + + AT_DISPATCH_FLOATING_TYPES_AND_HALF(x.scalar_type(), "upfirdn2d_cuda", [&] { + switch (mode) { + case 1: + upfirdn2d_kernel + <<>>(out.data_ptr(), + x.data_ptr(), + k.data_ptr(), p); + + break; + + case 2: + upfirdn2d_kernel + <<>>(out.data_ptr(), + x.data_ptr(), + k.data_ptr(), p); + + break; + + case 3: + upfirdn2d_kernel + <<>>(out.data_ptr(), + x.data_ptr(), + k.data_ptr(), p); + + break; + + case 4: + upfirdn2d_kernel + <<>>(out.data_ptr(), + x.data_ptr(), + k.data_ptr(), p); + + break; + + case 5: + upfirdn2d_kernel + <<>>(out.data_ptr(), + x.data_ptr(), + k.data_ptr(), p); + + break; + + case 6: + upfirdn2d_kernel + <<>>(out.data_ptr(), + x.data_ptr(), + k.data_ptr(), p); + + break; + + default: + upfirdn2d_kernel_large<<>>( + out.data_ptr(), x.data_ptr(), + k.data_ptr(), p); + } + }); + + return out; +} \ No newline at end of file diff --git a/source/stylegan2/prepare_data.py b/source/stylegan2/prepare_data.py new file mode 100755 index 0000000..ccffc72 --- /dev/null +++ b/source/stylegan2/prepare_data.py @@ -0,0 +1,103 @@ +import argparse +from io import BytesIO +import multiprocessing +from functools import partial + +from PIL import Image +import lmdb +from tqdm import tqdm +from torchvision import datasets +from torchvision.transforms import functional as trans_fn +import os + +def resize_and_convert(img, size, resample, quality=100): + img = trans_fn.resize(img, size, resample) + img = trans_fn.center_crop(img, size) + buffer = BytesIO() + img.save(buffer, format="jpeg", quality=quality) + val = buffer.getvalue() + + return val + + +def resize_multiple( + img, sizes=(128, 256, 512, 1024), resample=Image.LANCZOS, quality=100 +): + imgs = [] + + for size in sizes: + imgs.append(resize_and_convert(img, size, resample, quality)) + + return imgs + + +def resize_worker(img_file, sizes, resample): + i, file = img_file + img = Image.open(file) + img = img.convert("RGB") + out = resize_multiple(img, sizes=sizes, resample=resample) + + return i, out + + +def prepare( + env, dataset, n_worker, sizes=(128, 256, 512, 1024), resample=Image.LANCZOS +): + resize_fn = partial(resize_worker, sizes=sizes, resample=resample) + + files = sorted(dataset.imgs, key=lambda x: x[0]) + files = [(i, file) for i, (file, label) in enumerate(files)] + total = 0 + + with multiprocessing.Pool(n_worker) as pool: + for i, imgs in tqdm(pool.imap_unordered(resize_fn, files)): + for size, img in zip(sizes, imgs): + key = f"{size}-{str(i).zfill(5)}".encode("utf-8") + + with env.begin(write=True) as txn: + txn.put(key, img) + + total += 1 + + with env.begin(write=True) as txn: + txn.put("length".encode("utf-8"), str(total).encode("utf-8")) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description="Preprocess images for model training") + parser.add_argument("path", type=str, help="path to the image dataset") + parser.add_argument("--out", type=str, help="filename of the result lmdb dataset") + parser.add_argument( + "--size", + type=str, + default="128,256,512,1024", + help="resolutions of images for the dataset", + ) + parser.add_argument( + "--n_worker", + type=int, + default=16, + help="number of workers for preparing dataset", + ) + parser.add_argument( + "--resample", + type=str, + default="lanczos", + help="resampling methods for resizing images", + ) + + args = parser.parse_args() + if not os.path.exists(str(args.out)): + os.makedirs(str(args.out)) + + resample_map = {"lanczos": Image.LANCZOS, "bilinear": Image.BILINEAR} + resample = resample_map[args.resample] + + sizes = [int(s.strip()) for s in args.size.split(",")] + + print(f"Make dataset of image sizes:", ", ".join(str(s) for s in sizes)) + + imgset = datasets.ImageFolder(args.path) + + with lmdb.open(args.out, map_size=1024 ** 4, readahead=False) as env: + prepare(env, imgset, args.n_worker, sizes=sizes, resample=resample) diff --git a/source/stylegan2/style_blend.py b/source/stylegan2/style_blend.py new file mode 100755 index 0000000..85389a8 --- /dev/null +++ b/source/stylegan2/style_blend.py @@ -0,0 +1,145 @@ +# model blending technique +import os +import cv2 as cv +import torch +from model import Generator +import math +import argparse + +def extract_conv_names(model): + model = list(model.keys()) + conv_name = [] + resolutions = [4*2**x for x in range(9)] + level_names = [["Conv0_up", "Const"], ["Conv1", "ToRGB"]] + + +def blend_models(model_1, model_2, resolution, level, blend_width=None): + resolutions = [4 * 2 ** i for i in range(7)] + mid = resolutions.index(resolution) + + device = "cuda" + + size = 256 + latent = 512 + n_mlp = 8 + channel_multiplier =2 + G_1 = Generator( + size, latent, n_mlp, channel_multiplier=channel_multiplier + ).to(device) + ckpt_ffhq = torch.load(model_1, map_location=lambda storage, loc: storage) + G_1.load_state_dict(ckpt_ffhq["g"], strict=False) + + + G_2 = Generator( + size, latent, n_mlp, channel_multiplier=channel_multiplier + ).to(device) + ckpt_toon = torch.load(model_2) + G_2.load_state_dict(ckpt_toon["g_ema"]) + + + + # G_1 = stylegan2.models.load(model_1) + # G_2 = stylegan2.models.load(model_2) + model_1_state_dict = G_1.state_dict() + model_2_state_dict = G_2.state_dict() + assert(model_1_state_dict.keys() == model_2_state_dict.keys()) + G_out = G_1.clone() + + layers = [] + ys = [] + for k, v in model_1_state_dict.items(): + if k.startswith('convs.'): + pos = int(k[len('convs.')]) + x = pos - mid + if blend_width: + exponent = -x / blend_width + y = 1 / (1 + math.exp(exponent)) + else: + y = 1 if x > 0 else 0 + + layers.append(k) + ys.append(y) + elif k.startswith('to_rgbs.'): + pos = int(k[len('to_rgbs.')]) + x = pos - mid + if blend_width: + exponent = -x / blend_width + y = 1 / (1 + math.exp(exponent)) + else: + y = 1 if x > 0 else 0 + layers.append(k) + ys.append(y) + out_state = G_out.state_dict() + for y, layer in zip(ys, layers): + out_state[layer] = y * model_2_state_dict[layer] + \ + (1 - y) * model_1_state_dict[layer] + print('blend layer %s'%str(y)) + G_out.load_state_dict(out_state) + return G_out + + +def blend_models_2(model_1, model_2, resolution, level, blend_width=None): + # resolution = f"{resolution}x{resolution}" + resolutions = [4 * 2 ** i for i in range(7)] + mid = [resolutions.index(r) for r in resolution] + + G_1 = stylegan2.models.load(model_1) + G_2 = stylegan2.models.load(model_2) + model_1_state_dict = G_1.state_dict() + model_2_state_dict = G_2.state_dict() + assert(model_1_state_dict.keys() == model_2_state_dict.keys()) + G_out = G_1.clone() + + layers = [] + ys = [] + for k, v in model_1_state_dict.items(): + if k.startswith('G_synthesis.conv_blocks.'): + pos = int(k[len('G_synthesis.conv_blocks.')]) + y = 0 if pos in mid else 1 + layers.append(k) + ys.append(y) + elif k.startswith('G_synthesis.to_data_layers.'): + pos = int(k[len('G_synthesis.to_data_layers.')]) + y = 0 if pos in mid else 1 + layers.append(k) + ys.append(y) + # print(ys, layers) + out_state = G_out.state_dict() + for y, layer in zip(ys, layers): + out_state[layer] = y * model_2_state_dict[layer] + \ + (1 - y) * model_1_state_dict[layer] + G_out.load_state_dict(out_state) + return G_out + + +def main(name): + + resolution = 4 + + model_name = '001000.pt' + + G_out = blend_models("pretrained_models/stylegan2-ffhq-config-f-256-550000.pt", + "face_generation/experiment_stylegan/"+name+"/models/"+model_name, + resolution, + None) + # G_out.save('G_blend.pth') + outdir = os.path.join('face_generation/experiment_stylegan',name,'models_blend') + if not os.path.exists(outdir): + os.makedirs(outdir) + + outpath = os.path.join(outdir, 'G_blend_'+str(model_name[:-3])+'_'+ str(resolution)+'.pt') + torch.save( + { + "g_ema": G_out.state_dict(), + }, + # 'G_blend_570000_16.pth', + outpath + ) + + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description="style blender") + parser.add_argument('--name', type=str, default='') + args = parser.parse_args() + print('model name:%s'%args.name) + main(args.name) \ No newline at end of file diff --git a/source/stylegan2/train_condition.py b/source/stylegan2/train_condition.py new file mode 100755 index 0000000..9051194 --- /dev/null +++ b/source/stylegan2/train_condition.py @@ -0,0 +1,584 @@ +import os +import argparse +import math +import random +import json +import numpy as np +import torch +from torch import nn, autograd, optim +from torch.nn import functional as F +from torch.utils import data +import torch.distributed as dist +from torchvision import transforms, utils +from tqdm import tqdm +from criteria import id_loss + +try: + import wandb + +except ImportError: + wandb = None + + +from dataset import MultiResolutionDataset +from distributed import ( + get_rank, + synchronize, + reduce_loss_dict, + reduce_sum, + get_world_size, +) +from op import conv2d_gradfix +from non_leaking import augment, AdaptiveAugment + + +def data_sampler(dataset, shuffle, distributed): + if distributed: + return data.distributed.DistributedSampler(dataset, shuffle=shuffle) + + if shuffle: + return data.RandomSampler(dataset) + + else: + return data.SequentialSampler(dataset) + + +def requires_grad(model, flag=True): + for p in model.parameters(): + p.requires_grad = flag + + +def accumulate(model1, model2, decay=0.999): + par1 = dict(model1.named_parameters()) + par2 = dict(model2.named_parameters()) + + for k in par1.keys(): + par1[k].data.mul_(decay).add_(par2[k].data, alpha=1 - decay) + + +def sample_data(loader): + while True: + for batch in loader: + yield batch + + +def d_logistic_loss(real_pred, fake_pred): + real_loss = F.softplus(-real_pred) + fake_loss = F.softplus(fake_pred) + + return real_loss.mean() + fake_loss.mean() + + +def d_r1_loss(real_pred, real_img): + with conv2d_gradfix.no_weight_gradients(): + grad_real, = autograd.grad( + outputs=real_pred.sum(), inputs=real_img, create_graph=True + ) + grad_penalty = grad_real.pow(2).reshape(grad_real.shape[0], -1).sum(1).mean() + + return grad_penalty + + +def g_nonsaturating_loss(fake_pred): + loss = F.softplus(-fake_pred).mean() + + return loss + + +def g_path_regularize(fake_img, latents, mean_path_length, decay=0.01): + noise = torch.randn_like(fake_img) / math.sqrt( + fake_img.shape[2] * fake_img.shape[3] + ) + grad, = autograd.grad( + outputs=(fake_img * noise).sum(), inputs=latents, create_graph=True + ) + path_lengths = torch.sqrt(grad.pow(2).sum(2).mean(1)) + + path_mean = mean_path_length + decay * (path_lengths.mean() - mean_path_length) + + path_penalty = (path_lengths - path_mean).pow(2).mean() + + return path_penalty, path_mean.detach(), path_lengths + + +def make_noise(batch, latent_dim, n_noise, device): + if n_noise == 1: + return torch.randn(batch, latent_dim, device=device) + + noises = torch.randn(n_noise, batch, latent_dim, device=device).unbind(0) + + return noises + + +def mixing_noise(batch, latent_dim, prob, device): + if prob > 0 and random.random() < prob: + return make_noise(batch, latent_dim, 2, device) + + else: + return [make_noise(batch, latent_dim, 1, device)] + + +def set_grad_none(model, targets): + for n, p in model.named_parameters(): + if n in targets: + p.grad = None + + +def train(args, loader, generator, generator_source, discriminator, g_optim, d_optim, g_ema, device): + loader = sample_data(loader) + + pbar = range(args.iter) + + if get_rank() == 0: + pbar = tqdm(pbar, initial=args.start_iter, dynamic_ncols=True, smoothing=0.01) + + mean_path_length = 0 + + d_loss_val = 0 + r1_loss = torch.tensor(0.0, device=device) + g_loss_val = 0 + path_loss = torch.tensor(0.0, device=device) + path_lengths = torch.tensor(0.0, device=device) + mean_path_length_avg = 0 + loss_dict = {} + + ### add id loss, content loss + g_id_loss = id_loss.IDLoss().to(device).eval() + + if args.distributed: + g_module = generator.module + d_module = discriminator.module + + else: + g_module = generator + d_module = discriminator + + accum = 0.5 ** (32 / (10 * 1000)) + ada_aug_p = args.augment_p if args.augment_p > 0 else 0.0 + r_t_stat = 0 + + if args.augment and args.augment_p == 0: + ada_augment = AdaptiveAugment(args.ada_target, args.ada_length, 8, device) + + # sample_z = torch.randn(args.n_sample, args.latent, device=device) + sample_z = torch.load('noise.pt').to(device) + + for idx in pbar: + i = idx + args.start_iter + + if i > args.iter: + print("Done!") + + break + + real_img = next(loader) + real_img = real_img.to(device) + + requires_grad(generator, False) + requires_grad(discriminator, True) + + noise = mixing_noise(args.batch, args.latent, args.mixing, device) + fake_img, _ = generator(noise) + + if args.augment: + real_img_aug, _ = augment(real_img, ada_aug_p) + fake_img, _ = augment(fake_img, ada_aug_p) + + else: + real_img_aug = real_img + + fake_pred = discriminator(fake_img) + real_pred = discriminator(real_img_aug) + d_loss = d_logistic_loss(real_pred, fake_pred) + + loss_dict["d"] = d_loss + loss_dict["real_score"] = real_pred.mean() + loss_dict["fake_score"] = fake_pred.mean() + + discriminator.zero_grad() + d_loss.backward() + d_optim.step() + + if args.augment and args.augment_p == 0: + ada_aug_p = ada_augment.tune(real_pred) + r_t_stat = ada_augment.r_t_stat + + d_regularize = i % args.d_reg_every == 0 + + if d_regularize: + real_img.requires_grad = True + + if args.augment: + real_img_aug, _ = augment(real_img, ada_aug_p) + + else: + real_img_aug = real_img + + real_pred = discriminator(real_img_aug) + r1_loss = d_r1_loss(real_pred, real_img) + + discriminator.zero_grad() + (args.r1 / 2 * r1_loss * args.d_reg_every + 0 * real_pred[0]).backward() + + d_optim.step() + + loss_dict["r1"] = r1_loss + + requires_grad(generator, True) + requires_grad(discriminator, False) + + noise = mixing_noise(args.batch, args.latent, args.mixing, device) + fake_img, _ = generator(noise) + + + if args.augment: + fake_img, _ = augment(fake_img, ada_aug_p) + + fake_pred = discriminator(fake_img) + g_loss = g_nonsaturating_loss(fake_pred) + + ### id loss + fake_img_source, _ = generator_source(noise) + loss_id = g_id_loss(fake_img, fake_img_source) + loss_id = float(loss_id) + loss_dict['loss_id'] = loss_id + # print(loss_id) + + g_loss += loss_id*0.1 + + + loss_dict["g"] = g_loss + + generator.zero_grad() + g_loss.backward() + g_optim.step() + + g_regularize = i % args.g_reg_every == 0 + + if g_regularize: + path_batch_size = max(1, args.batch // args.path_batch_shrink) + noise = mixing_noise(path_batch_size, args.latent, args.mixing, device) + fake_img, latents = generator(noise, return_latents=True) + + path_loss, mean_path_length, path_lengths = g_path_regularize( + fake_img, latents, mean_path_length + ) + + generator.zero_grad() + weighted_path_loss = args.path_regularize * args.g_reg_every * path_loss + + if args.path_batch_shrink: + weighted_path_loss += 0 * fake_img[0, 0, 0, 0] + + weighted_path_loss.backward() + + g_optim.step() + + mean_path_length_avg = ( + reduce_sum(mean_path_length).item() / get_world_size() + ) + + loss_dict["path"] = path_loss + loss_dict["path_length"] = path_lengths.mean() + + accumulate(g_ema, g_module, accum) + + loss_reduced = reduce_loss_dict(loss_dict) + + d_loss_val = loss_reduced["d"].mean().item() + g_loss_val = loss_reduced["g"].mean().item() + r1_val = loss_reduced["r1"].mean().item() + path_loss_val = loss_reduced["path"].mean().item() + real_score_val = loss_reduced["real_score"].mean().item() + fake_score_val = loss_reduced["fake_score"].mean().item() + path_length_val = loss_reduced["path_length"].mean().item() + + if get_rank() == 0: + pbar.set_description( + ( + f"d: {d_loss_val:.4f}; g: {g_loss_val:.4f}; r1: {r1_val:.4f}; " + f"path: {path_loss_val:.4f}; mean path: {mean_path_length_avg:.4f}; " + f"augment: {ada_aug_p:.4f}" + ) + ) + + if wandb and args.wandb: + wandb.log( + { + "Generator": g_loss_val, + "Discriminator": d_loss_val, + "Augment": ada_aug_p, + "Rt": r_t_stat, + "R1": r1_val, + "Path Length Regularization": path_loss_val, + "Mean Path Length": mean_path_length, + "Real Score": real_score_val, + "Fake Score": fake_score_val, + "Path Length": path_length_val, + } + ) + + if i % args.sample_every == 0: + with torch.no_grad(): + g_ema.eval() + sample, _ = g_ema([sample_z]) + outpath = os.path.join(args.output, args.name,'sample', str(i).zfill(6)+'.png') + utils.save_image( + sample, + outpath, + # nrow=int(args.n_sample ** 0.5), + nrow=int(math.sqrt(sample.shape[0])), + normalize=True, + range=(-1, 1), + ) + + if i % args.save_every == 0: + outpath_ckpt = os.path.join(args.output, args.name, 'models', str(i).zfill(6) + '.pt') + torch.save( + { + "g": g_module.state_dict(), + "d": d_module.state_dict(), + "g_ema": g_ema.state_dict(), + "g_optim": g_optim.state_dict(), + "d_optim": d_optim.state_dict(), + "args": args, + "ada_aug_p": ada_aug_p, + }, + outpath_ckpt, + ) + + +if __name__ == "__main__": + device = "cuda" + + parser = argparse.ArgumentParser(description="StyleGAN2 trainer") + parser.add_argument('--config', type=str, default='config/conf_server_train_condition.json') + parser.add_argument("--path", type=str, help="path to the lmdb dataset") + parser.add_argument("--name", type=str, help="name of experiment") + parser.add_argument('--arch', type=str, default='stylegan2', help='model architectures (stylegan2 | swagan)') + parser.add_argument( + "--iter", type=int, default=800000, help="total training iterations" + ) + parser.add_argument( + "--batch", type=int, default=1, help="batch sizes for each gpus" + ) + parser.add_argument( + "--n_sample", + type=int, + default=64, + help="number of the samples generated during training", + ) + parser.add_argument( + "--size", type=int, default=1024, help="image sizes for the model" + ) + parser.add_argument( + "--r1", type=float, default=10, help="weight of the r1 regularization" + ) + parser.add_argument( + "--path_regularize", + type=float, + default=2, + help="weight of the path length regularization", + ) + parser.add_argument( + "--path_batch_shrink", + type=int, + default=2, + help="batch size reducing factor for the path length regularization (reduce memory consumption)", + ) + parser.add_argument( + "--d_reg_every", + type=int, + default=16, + help="interval of the applying r1 regularization", + ) + parser.add_argument( + "--g_reg_every", + type=int, + default=4, + help="interval of the applying path length regularization", + ) + parser.add_argument( + "--mixing", type=float, default=0.9, help="probability of latent code mixing" + ) + parser.add_argument( + "--ckpt", + type=str, + help="path to the checkpoints to resume training", + ) + parser.add_argument("--lr", type=float, default=0.002, help="learning rate") + parser.add_argument( + "--channel_multiplier", + type=int, + default=2, + help="channel multiplier factor for the model. config-f = 2, else = 1", + ) + parser.add_argument( + "--wandb", action="store_true", help="use weights and biases logging" + ) + parser.add_argument( + "--local_rank", type=int, default=0, help="local rank for distributed training" + ) + parser.add_argument( + "--augment", action="store_true", help="apply non leaking augmentation" + ) + parser.add_argument( + "--augment_p", + type=float, + default=0, + help="probability of applying augmentation. 0 = use adaptive augmentation", + ) + parser.add_argument( + "--ada_target", + type=float, + default=0.6, + help="target augmentation probability for adaptive augmentation", + ) + parser.add_argument( + "--ada_length", + type=int, + default=500 * 1000, + help="target duraing to reach augmentation probability for adaptive augmentation", + ) + parser.add_argument( + "--ada_every", + type=int, + default=256, + help="probability update interval of the adaptive augmentation", + ) + + args = parser.parse_args() + + # from config updata paras + opt = vars(args) + with open(args.config) as f: + config = json.load(f)['parameters'] + for key, value in config.items(): + opt[key] = value + + output_sample = os.path.join(args.output, args.name,'sample') + output_model = os.path.join(args.output, args.name,'models') + + if not os.path.exists(output_sample): + os.makedirs(output_sample) + if not os.path.exists(output_model): + os.makedirs(output_model) + + + n_gpu = int(os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1 + args.distributed = n_gpu > 1 + + if args.distributed: + torch.cuda.set_device(args.local_rank) + torch.distributed.init_process_group(backend="nccl", init_method="env://") + synchronize() + + args.latent = 512 + args.n_mlp = 8 + + args.start_iter = 0 + + if args.arch == 'stylegan2': + from model import Generator, Discriminator + + elif args.arch == 'swagan': + from swagan import Generator, Discriminator + + generator = Generator( + args.size, args.latent, args.n_mlp, channel_multiplier=args.channel_multiplier + ).to(device) + + ### add source G + generator_source = Generator( + args.size, args.latent, args.n_mlp, channel_multiplier=args.channel_multiplier + ).to(device) + generator_source.eval() + + discriminator = Discriminator( + args.size, channel_multiplier=args.channel_multiplier + ).to(device) + g_ema = Generator( + args.size, args.latent, args.n_mlp, channel_multiplier=args.channel_multiplier + ).to(device) + g_ema.eval() + accumulate(g_ema, generator, 0) + + g_reg_ratio = args.g_reg_every / (args.g_reg_every + 1) + d_reg_ratio = args.d_reg_every / (args.d_reg_every + 1) + + g_optim = optim.Adam( + generator.parameters(), + lr=args.lr * g_reg_ratio, + betas=(0 ** g_reg_ratio, 0.99 ** g_reg_ratio), + ) + d_optim = optim.Adam( + discriminator.parameters(), + lr=args.lr * d_reg_ratio, + betas=(0 ** d_reg_ratio, 0.99 ** d_reg_ratio), + ) + + if args.ckpt is not None: + print("load model:", args.ckpt) + + ckpt = torch.load(args.ckpt, map_location=lambda storage, loc: storage) + + try: + ckpt_name = os.path.basename(args.ckpt) + args.start_iter = int(os.path.splitext(ckpt_name)[0]) + + except ValueError: + pass + + generator.load_state_dict(ckpt["g"], strict=False) + discriminator.load_state_dict(ckpt["d"], strict=False) + g_ema.load_state_dict(ckpt["g_ema"], strict=False) + + if args.ckpt_ffhq is not None: + ckpt_ffhq = torch.load(args.ckpt_ffhq, map_location=lambda storage, loc: storage) + generator_source.load_state_dict(ckpt_ffhq["g"], strict=False) + else: + print('No source ckpt!') + + + # generator.load_state_dict(ckpt["g"]) + # discriminator.load_state_dict(ckpt["d"]) + # g_ema.load_state_dict(ckpt["g_ema"]) + + # g_optim.load_state_dict(ckpt["g_optim"]) + # d_optim.load_state_dict(ckpt["d_optim"]) + + if args.distributed: + generator = nn.parallel.DistributedDataParallel( + generator, + device_ids=[args.local_rank], + output_device=args.local_rank, + broadcast_buffers=False, + ) + + discriminator = nn.parallel.DistributedDataParallel( + discriminator, + device_ids=[args.local_rank], + output_device=args.local_rank, + broadcast_buffers=False, + ) + + transform = transforms.Compose( + [ + transforms.RandomHorizontalFlip(), + transforms.ToTensor(), + transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5), inplace=True), + ] + ) + + dataset = MultiResolutionDataset(args.path, transform, args.size) + loader = data.DataLoader( + dataset, + batch_size=args.batch, + sampler=data_sampler(dataset, shuffle=True, distributed=args.distributed), + drop_last=True, + ) + + if get_rank() == 0 and wandb is not None and args.wandb: + wandb.init(project="stylegan 2") + + train(args, loader, generator, generator_source, discriminator, g_optim, d_optim, g_ema, device) diff --git a/train_localtoon.py b/train_localtoon.py new file mode 100644 index 0000000..da41c01 --- /dev/null +++ b/train_localtoon.py @@ -0,0 +1,36 @@ +import os +import cv2 +from modelscope.trainers.cv import CartoonTranslationTrainer + + +def main(args): + + data_photo = os.path.join(args.data_dir, 'face_photo') + data_cartoon = os.path.join(args.data_dir, 'face_cartoon') + + style = args.style + if style == "anime": + style = "" + else: + style = '-' + style + model_id = 'damo/cv_unet_person-image-cartoon' + style + '_compound-models' + + max_steps = 300000 + trainer = CartoonTranslationTrainer( + model=model_id, + work_dir=args.work_dir, + photo=data_photo, + cartoon=data_cartoon, + max_steps=max_steps) + trainer.train() + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description="process remove bg result") + parser.add_argument("--data_dir", type=str, default='', help="Path to training images.") + parser.add_argument("--work_dir", type=str, default='', help="Path to save results.") + parser.add_argument("--style", type=str, default='anime', help="resume training from similar style.") + + args = parser.parse_args() + + main(args) +