From 4f9296236a3cb46ccc1f9548ec6eba32eff8c906 Mon Sep 17 00:00:00 2001
From: zhurui <274461951@qq.com>
Date: Thu, 4 Jul 2024 17:06:52 +0800
Subject: [PATCH] first commit
---
LICENSE | 21 +
README.md | 287 ++++
cog.yaml | 34 +
cog_predict.py | 196 +++
criteria/__init__.py | 0
criteria/clip_loss.py | 17 +
criteria/id_loss.py | 40 +
global_torch/SingleChannel.py | 127 ++
global_torch/StyleCLIP.py | 246 ++++
global_torch/dnnlib/__init__.py | 9 +
global_torch/dnnlib/util.py | 477 ++++++
global_torch/html/[6]_501_c.html | 99 ++
global_torch/html/real_.html | 223 +++
global_torch/legacy.py | 326 +++++
global_torch/manipulate.py | 383 +++++
global_torch/npy/ffhq/fs3.npy | Bin 0 -> 6193280 bytes
global_torch/npy/human/fs3.npy | Bin 0 -> 5505152 bytes
global_torch/torch_utils/__init__.py | 9 +
global_torch/torch_utils/custom_ops.py | 126 ++
global_torch/torch_utils/misc.py | 262 ++++
global_torch/torch_utils/ops/__init__.py | 9 +
global_torch/torch_utils/ops/bias_act.cpp | 99 ++
global_torch/torch_utils/ops/bias_act.cu | 173 +++
global_torch/torch_utils/ops/bias_act.h | 38 +
global_torch/torch_utils/ops/bias_act.py | 212 +++
.../torch_utils/ops/conv2d_gradfix.py | 170 +++
.../torch_utils/ops/conv2d_resample.py | 156 ++
global_torch/torch_utils/ops/fma.py | 60 +
global_torch/torch_utils/ops/fused_act.py | 34 +
.../torch_utils/ops/grid_sample_gradfix.py | 83 ++
global_torch/torch_utils/ops/upfirdn2d.cpp | 103 ++
global_torch/torch_utils/ops/upfirdn2d.cu | 350 +++++
global_torch/torch_utils/ops/upfirdn2d.h | 59 +
global_torch/torch_utils/ops/upfirdn2d.py | 384 +++++
global_torch/torch_utils/persistence.py | 251 ++++
global_torch/torch_utils/training_stats.py | 268 ++++
global_torch/training/__init__.py | 9 +
global_torch/training/networks.py | 809 +++++++++++
global_torch/visualizer.py | 605 ++++++++
latents_test/example_celebs.pt | Bin 0 -> 221944 bytes
licenses/LICENSE-CLIP | 21 +
licenses/LICENSE-stylegan2-pytorch | 21 +
models/__init__.py | 0
models/facial_recognition/__init__.py | 0
models/facial_recognition/helpers.py | 119 ++
models/facial_recognition/model_irse.py | 86 ++
models/stylegan2/__init__.py | 0
models/stylegan2/model.py | 715 +++++++++
models/stylegan2/op/__init__.py | 2 +
.../op/__pycache__/__init__.cpython-310.pyc | Bin 0 -> 265 bytes
.../op/__pycache__/fused_act.cpython-310.pyc | Bin 0 -> 1330 bytes
.../op/__pycache__/upfirdn2d.cpython-310.pyc | Bin 0 -> 1464 bytes
models/stylegan2/op/fused_act.py | 40 +
models/stylegan2/op/upfirdn2d.py | 60 +
models/stylegan3/dnnlib/__init__.py | 9 +
.../__pycache__/__init__.cpython-310.pyc | Bin 0 -> 219 bytes
.../dnnlib/__pycache__/util.cpython-310.pyc | Bin 0 -> 13959 bytes
models/stylegan3/dnnlib/util.py | 491 +++++++
models/stylegan3/model_3.py | 529 +++++++
models/stylegan3/run_optimization3.py | 267 ++++
models/stylegan3/show_pkl.py | 194 +++
models/stylegan3/test001_s3.py | 37 +
models/stylegan3/torch_utils/__init__.py | 9 +
models/stylegan3/torch_utils/custom_ops.py | 157 ++
models/stylegan3/torch_utils/misc.py | 267 ++++
models/stylegan3/torch_utils/ops/__init__.py | 9 +
.../ops/__pycache__/__init__.cpython-310.pyc | Bin 0 -> 161 bytes
.../ops/__pycache__/bias_act.cpython-310.pyc | Bin 0 -> 8289 bytes
.../conv2d_gradfix.cpython-310.pyc | Bin 0 -> 7314 bytes
.../conv2d_resample.cpython-310.pyc | Bin 0 -> 4438 bytes
.../filtered_lrelu.cpython-310.pyc | Bin 0 -> 10063 bytes
.../ops/__pycache__/fma.cpython-310.pyc | Bin 0 -> 1709 bytes
.../grid_sample_gradfix.cpython-310.pyc | Bin 0 -> 2575 bytes
.../ops/__pycache__/upfirdn2d.cpython-310.pyc | Bin 0 -> 14161 bytes
models/stylegan3/torch_utils/ops/bias_act.cpp | 99 ++
models/stylegan3/torch_utils/ops/bias_act.cu | 173 +++
models/stylegan3/torch_utils/ops/bias_act.h | 38 +
models/stylegan3/torch_utils/ops/bias_act.py | 209 +++
.../torch_utils/ops/conv2d_gradfix.py | 203 +++
.../torch_utils/ops/conv2d_resample.py | 143 ++
.../torch_utils/ops/filtered_lrelu.cpp | 300 ++++
.../torch_utils/ops/filtered_lrelu.cu | 1284 +++++++++++++++++
.../torch_utils/ops/filtered_lrelu.h | 90 ++
.../torch_utils/ops/filtered_lrelu.py | 274 ++++
.../torch_utils/ops/filtered_lrelu_ns.cu | 27 +
.../torch_utils/ops/filtered_lrelu_rd.cu | 27 +
.../torch_utils/ops/filtered_lrelu_wr.cu | 27 +
models/stylegan3/torch_utils/ops/fma.py | 60 +
.../torch_utils/ops/grid_sample_gradfix.py | 86 ++
.../stylegan3/torch_utils/ops/upfirdn2d.cpp | 107 ++
models/stylegan3/torch_utils/ops/upfirdn2d.cu | 384 +++++
models/stylegan3/torch_utils/ops/upfirdn2d.h | 59 +
models/stylegan3/torch_utils/ops/upfirdn2d.py | 389 +++++
models/stylegan3/torch_utils/persistence.py | 251 ++++
.../stylegan3/torch_utils/training_stats.py | 268 ++++
optimization/run_optimization.py | 181 +++
test001.py | 36 +
test002.py | 27 +
utils.py | 49 +
99 files changed, 14578 insertions(+)
create mode 100644 LICENSE
create mode 100644 README.md
create mode 100644 cog.yaml
create mode 100644 cog_predict.py
create mode 100644 criteria/__init__.py
create mode 100644 criteria/clip_loss.py
create mode 100644 criteria/id_loss.py
create mode 100644 global_torch/SingleChannel.py
create mode 100644 global_torch/StyleCLIP.py
create mode 100644 global_torch/dnnlib/__init__.py
create mode 100644 global_torch/dnnlib/util.py
create mode 100644 global_torch/html/[6]_501_c.html
create mode 100644 global_torch/html/real_.html
create mode 100644 global_torch/legacy.py
create mode 100644 global_torch/manipulate.py
create mode 100644 global_torch/npy/ffhq/fs3.npy
create mode 100644 global_torch/npy/human/fs3.npy
create mode 100644 global_torch/torch_utils/__init__.py
create mode 100644 global_torch/torch_utils/custom_ops.py
create mode 100644 global_torch/torch_utils/misc.py
create mode 100644 global_torch/torch_utils/ops/__init__.py
create mode 100644 global_torch/torch_utils/ops/bias_act.cpp
create mode 100644 global_torch/torch_utils/ops/bias_act.cu
create mode 100644 global_torch/torch_utils/ops/bias_act.h
create mode 100644 global_torch/torch_utils/ops/bias_act.py
create mode 100644 global_torch/torch_utils/ops/conv2d_gradfix.py
create mode 100644 global_torch/torch_utils/ops/conv2d_resample.py
create mode 100644 global_torch/torch_utils/ops/fma.py
create mode 100644 global_torch/torch_utils/ops/fused_act.py
create mode 100644 global_torch/torch_utils/ops/grid_sample_gradfix.py
create mode 100644 global_torch/torch_utils/ops/upfirdn2d.cpp
create mode 100644 global_torch/torch_utils/ops/upfirdn2d.cu
create mode 100644 global_torch/torch_utils/ops/upfirdn2d.h
create mode 100644 global_torch/torch_utils/ops/upfirdn2d.py
create mode 100644 global_torch/torch_utils/persistence.py
create mode 100644 global_torch/torch_utils/training_stats.py
create mode 100644 global_torch/training/__init__.py
create mode 100644 global_torch/training/networks.py
create mode 100644 global_torch/visualizer.py
create mode 100644 latents_test/example_celebs.pt
create mode 100644 licenses/LICENSE-CLIP
create mode 100644 licenses/LICENSE-stylegan2-pytorch
create mode 100644 models/__init__.py
create mode 100644 models/facial_recognition/__init__.py
create mode 100644 models/facial_recognition/helpers.py
create mode 100644 models/facial_recognition/model_irse.py
create mode 100644 models/stylegan2/__init__.py
create mode 100644 models/stylegan2/model.py
create mode 100644 models/stylegan2/op/__init__.py
create mode 100644 models/stylegan2/op/__pycache__/__init__.cpython-310.pyc
create mode 100644 models/stylegan2/op/__pycache__/fused_act.cpython-310.pyc
create mode 100644 models/stylegan2/op/__pycache__/upfirdn2d.cpython-310.pyc
create mode 100644 models/stylegan2/op/fused_act.py
create mode 100644 models/stylegan2/op/upfirdn2d.py
create mode 100644 models/stylegan3/dnnlib/__init__.py
create mode 100644 models/stylegan3/dnnlib/__pycache__/__init__.cpython-310.pyc
create mode 100644 models/stylegan3/dnnlib/__pycache__/util.cpython-310.pyc
create mode 100644 models/stylegan3/dnnlib/util.py
create mode 100644 models/stylegan3/model_3.py
create mode 100644 models/stylegan3/run_optimization3.py
create mode 100644 models/stylegan3/show_pkl.py
create mode 100644 models/stylegan3/test001_s3.py
create mode 100644 models/stylegan3/torch_utils/__init__.py
create mode 100644 models/stylegan3/torch_utils/custom_ops.py
create mode 100644 models/stylegan3/torch_utils/misc.py
create mode 100644 models/stylegan3/torch_utils/ops/__init__.py
create mode 100644 models/stylegan3/torch_utils/ops/__pycache__/__init__.cpython-310.pyc
create mode 100644 models/stylegan3/torch_utils/ops/__pycache__/bias_act.cpython-310.pyc
create mode 100644 models/stylegan3/torch_utils/ops/__pycache__/conv2d_gradfix.cpython-310.pyc
create mode 100644 models/stylegan3/torch_utils/ops/__pycache__/conv2d_resample.cpython-310.pyc
create mode 100644 models/stylegan3/torch_utils/ops/__pycache__/filtered_lrelu.cpython-310.pyc
create mode 100644 models/stylegan3/torch_utils/ops/__pycache__/fma.cpython-310.pyc
create mode 100644 models/stylegan3/torch_utils/ops/__pycache__/grid_sample_gradfix.cpython-310.pyc
create mode 100644 models/stylegan3/torch_utils/ops/__pycache__/upfirdn2d.cpython-310.pyc
create mode 100644 models/stylegan3/torch_utils/ops/bias_act.cpp
create mode 100644 models/stylegan3/torch_utils/ops/bias_act.cu
create mode 100644 models/stylegan3/torch_utils/ops/bias_act.h
create mode 100644 models/stylegan3/torch_utils/ops/bias_act.py
create mode 100644 models/stylegan3/torch_utils/ops/conv2d_gradfix.py
create mode 100644 models/stylegan3/torch_utils/ops/conv2d_resample.py
create mode 100644 models/stylegan3/torch_utils/ops/filtered_lrelu.cpp
create mode 100644 models/stylegan3/torch_utils/ops/filtered_lrelu.cu
create mode 100644 models/stylegan3/torch_utils/ops/filtered_lrelu.h
create mode 100644 models/stylegan3/torch_utils/ops/filtered_lrelu.py
create mode 100644 models/stylegan3/torch_utils/ops/filtered_lrelu_ns.cu
create mode 100644 models/stylegan3/torch_utils/ops/filtered_lrelu_rd.cu
create mode 100644 models/stylegan3/torch_utils/ops/filtered_lrelu_wr.cu
create mode 100644 models/stylegan3/torch_utils/ops/fma.py
create mode 100644 models/stylegan3/torch_utils/ops/grid_sample_gradfix.py
create mode 100644 models/stylegan3/torch_utils/ops/upfirdn2d.cpp
create mode 100644 models/stylegan3/torch_utils/ops/upfirdn2d.cu
create mode 100644 models/stylegan3/torch_utils/ops/upfirdn2d.h
create mode 100644 models/stylegan3/torch_utils/ops/upfirdn2d.py
create mode 100644 models/stylegan3/torch_utils/persistence.py
create mode 100644 models/stylegan3/torch_utils/training_stats.py
create mode 100644 optimization/run_optimization.py
create mode 100644 test001.py
create mode 100644 test002.py
create mode 100644 utils.py
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..2130995
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Or Patashnik, Zongze Wu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..f04fbc6
--- /dev/null
+++ b/README.md
@@ -0,0 +1,287 @@
+# StyleCLIP: Text-Driven Manipulation of StyleGAN Imagery (ICCV 2021 Oral)
+
+[Run this model on Replicate](https://replicate.ai/orpatashnik/styleclip)
+
+Optimization: [](http://colab.research.google.com/github/orpatashnik/StyleCLIP/blob/main/notebooks/optimization_playground.ipynb)
+Mapper: [](https://colab.research.google.com/github/orpatashnik/StyleCLIP/blob/main/notebooks/mapper_playground.ipynb)
+
+Global directions Torch: [](https://colab.research.google.com/github/orpatashnik/StyleCLIP/blob/main/notebooks/StyleCLIP_global_torch.ipynb)
+Global directions TF1: [](https://colab.research.google.com/github/orpatashnik/StyleCLIP/blob/main/notebooks/StyleCLIP_global.ipynb)
+
+
+
+ 
+
+Full Demo Video: 
ICCV Video
+
+
+
+
+
+
+
+> **StyleCLIP: Text-Driven Manipulation of StyleGAN Imagery**
+> Or Patashnik*, Zongze Wu*, Eli Shechtman, Daniel Cohen-Or, Dani Lischinski
+> *Equal contribution, ordered alphabetically
+> https://arxiv.org/abs/2103.17249
+>
+>**Abstract:** Inspired by the ability of StyleGAN to generate highly realistic
+images in a variety of domains, much recent work has
+focused on understanding how to use the latent spaces of
+StyleGAN to manipulate generated and real images. However,
+discovering semantically meaningful latent manipulations
+typically involves painstaking human examination of
+the many degrees of freedom, or an annotated collection
+of images for each desired manipulation. In this work, we
+explore leveraging the power of recently introduced Contrastive
+Language-Image Pre-training (CLIP) models in order
+to develop a text-based interface for StyleGAN image
+manipulation that does not require such manual effort. We
+first introduce an optimization scheme that utilizes a CLIP-based
+loss to modify an input latent vector in response to a
+user-provided text prompt. Next, we describe a latent mapper
+that infers a text-guided latent manipulation step for
+a given input image, allowing faster and more stable textbased
+manipulation. Finally, we present a method for mapping
+a text prompts to input-agnostic directions in StyleGAN’s
+style space, enabling interactive text-driven image
+manipulation. Extensive results and comparisons demonstrate
+the effectiveness of our approaches.
+
+
+## Description
+Official Implementation of StyleCLIP, a method to manipulate images using a driving text.
+Our method uses the generative power of a pretrained StyleGAN generator, and the visual-language power of CLIP.
+In the paper we present three methods:
+- Latent vector optimization.
+- Latent mapper, trained to manipulate latent vectors according to a specific text description.
+- Global directions in the StyleSpace.
+
+
+## Updates
+**31/10/2022** Add support for global direction with torch implementation
+
+**15/8/2021** Add support for StyleSpace in optimization and latent mapper methods
+
+**6/4/2021** Add mapper training and inference (including a jupyter notebook) code
+
+**6/4/2021** Add support for custom StyleGAN2 and StyleGAN2-ada models, and also custom images
+
+**2/4/2021** Add the global directions code (a local GUI and a colab notebook)
+
+**31/3/2021** Upload paper to arxiv, and video to YouTube
+
+**14/2/2021** Initial version
+
+## Setup (for all three methods)
+For all the methods described in the paper, is it required to have:
+- Anaconda
+- [CLIP](https://github.com/openai/CLIP)
+
+Specific requirements for each method are described in its section.
+To install CLIP please run the following commands:
+ ```shell script
+conda install --yes -c pytorch pytorch=1.7.1 torchvision cudatoolkit=
+pip install ftfy regex tqdm gdown
+pip install git+https://github.com/openai/CLIP.git
+```
+
+
+## Editing via Latent Vector Optimization
+
+### Setup
+
+Here, the code relies on the [Rosinality](https://github.com/rosinality/stylegan2-pytorch/) pytorch implementation of StyleGAN2.
+Some parts of the StyleGAN implementation were modified, so that the whole implementation is native pytorch.
+
+In addition to the requirements mentioned before, a pretrained StyleGAN2 generator will attempt to be downloaded, (or manually download from [here](https://drive.google.com/file/d/1EM87UquaoQmk17Q8d5kYIAHqu0dkYqdT/view?usp=sharing)).
+
+### Usage
+
+Given a textual description, one can both edit a given image, or generate a random image that best fits to the description.
+Both operations can be done through the `main.py` script, or the `optimization_playground.ipynb` notebook ([](http://colab.research.google.com/github/orpatashnik/StyleCLIP/blob/main/notebooks/optimization_playground.ipynb)).
+
+#### Editing
+To edit an image set `--mode=edit`. Editing can be done on both provided latent vector, and on a random latent vector from StyleGAN's latent space.
+It is recommended to adjust the `--l2_lambda` according to the desired edit.
+
+#### Generating Free-style Images
+To generate a free-style image set `--mode=free_generation`.
+
+## Editing via Latent Mapper
+Here, we provide the code for the latent mapper. The mapper is trained to learn *residuals* from a given latent vector, according to the driving text.
+The code for the mapper is in `mapper/`.
+
+### Setup
+As in the optimization, the code relies on [Rosinality](https://github.com/rosinality/stylegan2-pytorch/) pytorch implementation of StyleGAN2.
+In addition the the StyleGAN weights, it is neccessary to have weights for the facial recognition network used in the ID loss.
+The weights can be downloaded from [here](https://drive.google.com/file/d/1KW7bjndL3QG3sxBbZxreGHigcCCpsDgn/view?usp=sharing).
+
+The mapper is trained on latent vectors. It is recommended to train on *inverted real images*.
+To this end, we provide the CelebA-HQ that was inverted by e4e:
+[train set](https://drive.google.com/file/d/1gof8kYc_gDLUT4wQlmUdAtPnQIlCO26q/view?usp=sharing), [test set](https://drive.google.com/file/d/1j7RIfmrCoisxx3t-r-KC02Qc8barBecr/view?usp=sharing).
+
+### Usage
+
+#### Training
+- The main training script is placed in `mapper/scripts/train.py`.
+- Training arguments can be found at `mapper/options/train_options.py`.
+- Intermediate training results are saved to opts.exp_dir. This includes checkpoints, train outputs, and test outputs.
+Additionally, if you have tensorboard installed, you can visualize tensorboard logs in opts.exp_dir/logs.
+Note that
+- To resume a training, please provide `--checkpoint_path`.
+- `--description` is where you provide the driving text.
+- If you perform an edit that is not supposed to change "colors" in the image, it is recommended to use the flag `--no_fine_mapper`.
+
+Example for training a mapper for the moahwk hairstyle:
+```bash
+cd mapper
+python train.py --exp_dir ../results/mohawk_hairstyle --no_fine_mapper --description "mohawk hairstyle"
+```
+All configurations for the examples shown in the paper are provided there.
+
+#### Inference
+- The main inferece script is placed in `mapper/scripts/inference.py`.
+- Inference arguments can be found at `mapper/options/test_options.py`.
+- Adding the flag `--couple_outputs` will save image containing the input and output images side-by-side.
+
+Pretrained models for variuos edits are provided. Please refer to `utils.py` for the complete links list.
+
+We also provide a notebook for performing inference with the mapper Mapper notebook: [](https://colab.research.google.com/github/orpatashnik/StyleCLIP/blob/main/notebooks/mapper_playground.ipynb)
+
+## Editing via Global Direction
+
+Here we provide GUI for editing images with the global directions.
+We provide both a jupyter notebook [](https://colab.research.google.com/github/orpatashnik/StyleCLIP/blob/main/notebooks/StyleCLIP_global.ipynb),
+and the GUI used in the [video](https://www.youtube.com/watch?v=5icI0NgALnQ).
+For both, the linear direction are computed in **real time**.
+The code is located at `global_directions/`.
+
+
+### Setup
+Here, we rely on the [official](https://github.com/NVlabs/stylegan2) TensorFlow implementation of StyleGAN2.
+
+It is required to have TensorFlow, version 1.14 or 1.15 (`conda install -c anaconda tensorflow-gpu==1.14`).
+
+### Usage
+
+
+#### Local GUI
+
+To start the local GUI please run the following commands:
+
+```shell script
+cd global_directions
+
+# input dataset name
+dataset_name='ffhq'
+
+# pretrained StyleGAN2 model from standard [NVlabs implementation](https://github.com/NVlabs/stylegan2) will be download automatically.
+# pretrained StyleGAN2-ada model could be download from https://nvlabs-fi-cdn.nvidia.com/stylegan2-ada/pretrained/ .
+# for custom StyleGAN2 or StyleGAN2-ada model, please place the model under ./StyleCLIP/global_directions/model/ folder.
+
+
+# input prepare data
+python GetCode.py --dataset_name $dataset_name --code_type 'w'
+python GetCode.py --dataset_name $dataset_name --code_type 's'
+python GetCode.py --dataset_name $dataset_name --code_type 's_mean_std'
+
+# preprocess (this may take a few hours).
+# we precompute the results for StyleGAN2 on ffhq, StyleGAN2-ada on afhqdog, afhqcat. For these model, we can skip the preprocess step.
+python SingleChannel.py --dataset_name $dataset_name
+
+# generated image to be manipulated
+# this operation will generate and replace the w_plu.npy and .jpg images in './data/dataset_name/' folder.
+# if you you want to keep the original data, please rename the original folder.
+# to use custom images, please use e4e encoder to generate latents.pt, and place it in './data/dataset_name/' folder, and add --real flag while running this function.
+# you may skip this step if you want to manipulate the real human faces we prepare in ./data/ffhq/ folder.
+python GetGUIData.py --dataset_name $dataset_name
+
+# interactively manipulation
+python PlayInteractively.py --dataset_name $dataset_name
+```
+
+As shown in the video, to edit an image it is requires to write a _neutral text_ and a _target text_.
+To operate the GUI, please do the following:
+- Maximize the window size
+- Double click on the left square to choose an image. The images are taken from `global_directions/data/ffhq`, and the corresponding latent vectors are in `global_directions/data/ffhq/w_plus.npy`.
+- Type a neutral text, then press enter
+- Modify the target text so that it will contain the target edit, then press enter.
+
+You can now play with:
+- *Manipulation strength* - positive values correspond to moving along the target direction.
+- *Disentanglement threshold* - large value means more disentangled edit, just a few channels will be manipulated so only the target attribute will change (for example, grey hair). Small value means less disentangled edit, a large number of channels will be manipulated, related attributes will also change (such as wrinkle, skin color, glasses).
+
+##### Examples:
+
+| Edit | Neutral Text | Target Text |
+| --- | --- | --- |
+| Smile | face | smiling face |
+| Gender | female face | male face |
+| Blonde hair | face with hair | face with blonde hair |
+| Hi-top fade | face with hair | face with Hi-top fade hair |
+| Blue eyes | face with eyes | face with blue eyes |
+
+More examples could be found in the [video](https://www.youtube.com/watch?v=5icI0NgALnQ) and in the paper.
+
+
+##### Pratice Tips:
+In the terminal, for every manipulation, the number of channels being manipulated is printed (the number is controlled by the attribute (neutral, target) and the disentanglement threshold).
+
+1. For color transformation, usually 10-20 channels is enough. For large structure change (for example, Hi-top fade), usually 100-200 channels are required.
+2. For an attribute (neutral, target), if you give a low disentanglement threshold, there are just few channels (<20) being manipulated, and usually it is not enough for performing the desired edit.
+
+
+#### Notebook
+Open the notebook in colab and run all the cells. In the last cell you can play with the image.
+
+`beta` corresponds to the *disentanglement threshold*, and `alpha` to the *manipulation strength*.
+
+After you set the desired set of parameters, please run again the last cell to generate the image.
+
+## Editing Examples
+
+In the following, we show some results obtained with our methods.
+All images are real, and were inverted into the StyleGAN's latent space using [e4e](https://github.com/omertov/encoder4editing).
+The driving text that was used for each edit appears below or above each image.
+
+#### Latent Optimization
+
+
+
+
+
+
+#### Latent Mapper
+
+
+
+#### Global Directions
+
+
+
+
+
+
+## Related Works
+
+The global directions we find for editing are direction in the _S Space_, which was introduced and analyzed in [StyleSpace](https://arxiv.org/abs/2011.12799) (Wu et al).
+
+To edit real images, we inverted them to the StyleGAN's latent space using [e4e](https://arxiv.org/abs/2102.02766) (Tov et al.).
+
+The code strcuture of the mapper is heavily based on [pSp](https://github.com/eladrich/pixel2style2pixel).
+
+## Citation
+
+If you use this code for your research, please cite our paper:
+
+```
+@InProceedings{Patashnik_2021_ICCV,
+ author = {Patashnik, Or and Wu, Zongze and Shechtman, Eli and Cohen-Or, Daniel and Lischinski, Dani},
+ title = {StyleCLIP: Text-Driven Manipulation of StyleGAN Imagery},
+ booktitle = {Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV)},
+ month = {October},
+ year = {2021},
+ pages = {2085-2094}
+}
+```
diff --git a/cog.yaml b/cog.yaml
new file mode 100644
index 0000000..dda2570
--- /dev/null
+++ b/cog.yaml
@@ -0,0 +1,34 @@
+build:
+ gpu: true
+ system_packages:
+ - libgl1-mesa-glx
+ - libglib2.0-0
+ - cmake
+ - zip
+ python_version: 3.7
+ python_packages:
+ - torch==1.7.1
+ - tensorflow==1.15.0
+ - torchvision==0.8.2
+ - torchaudio==0.7.2
+ - ftfy==5.9
+ - regex==2021.4.4
+ - tqdm==4.59.0
+ - requests==2.25.1
+ - matplotlib==3.4.1
+ - opencv-python==4.3.0.38
+ - dlib==19.18.0
+ - scipy==1.6.3
+ - "git+git://github.com/openai/CLIP.git@8a665a683d791ed3491fedadcb3c91878f9eb78d"
+ pre_install:
+ - "mkdir /content"
+ - "git clone https://github.com/omertov/encoder4editing.git /content/encoder4editing"
+ - "wget https://github.com/ninja-build/ninja/releases/download/v1.8.2/ninja-linux.zip"
+ - "unzip ninja-linux.zip -d /usr/local/bin/"
+ - "update-alternatives --install /usr/bin/ninja ninja /usr/local/bin/ninja 1 --force"
+ - "wget -O /content/shape_predictor_68_face_landmarks.dat.bz2 http://dlib.net/files/shape_predictor_68_face_landmarks.dat.bz2"
+ - "cd /content && bzip2 -dk shape_predictor_68_face_landmarks.dat.bz2"
+ - "echo > /content/encoder4editing/__init__.py"
+ - |
+ sed -i 's/img = PIL.Image.open(filepath)/img = PIL.Image.open(filepath).convert(\"RGB\")/' /content/encoder4editing/utils/alignment.py
+predict: cog_predict.py:Predictor
diff --git a/cog_predict.py b/cog_predict.py
new file mode 100644
index 0000000..2bbf6fb
--- /dev/null
+++ b/cog_predict.py
@@ -0,0 +1,196 @@
+import copy
+import os
+import pickle
+import sys
+import tempfile
+import time
+from argparse import Namespace
+from pathlib import Path
+
+import clip
+import cog
+import dlib
+import matplotlib.pyplot as plt
+import numpy as np
+import tensorflow as tf
+import torch
+import torchvision.transforms as transforms
+from PIL import Image
+
+sys.path.insert(0, "/content")
+sys.path.insert(0, "/content/encoder4editing")
+
+from encoder4editing.models.psp import pSp
+from encoder4editing.utils.alignment import align_face
+from encoder4editing.utils.common import tensor2im
+
+os.chdir("global_directions")
+sys.path.insert(0, ".")
+
+from dnnlib import tflib
+from manipulate import Manipulator
+from MapTS import GetBoundary, GetDt, GetFs
+
+class Predictor(cog.Predictor):
+ def setup(self):
+
+ print("starting setup")
+
+ self.device = "cuda" if torch.cuda.is_available() else "cpu"
+ self.model, self.preprocess = clip.load(
+ "ViT-B/32", device=self.device, jit=False
+ )
+
+ self.graph = tf.get_default_graph()
+ gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.333)
+ self.sess = tf.Session(
+ graph=self.graph, config=tf.ConfigProto(gpu_options=gpu_options)
+ )
+
+ self.experiment_args = {"model_path": "e4e_ffhq_encode.pt"}
+ self.experiment_args["transform"] = transforms.Compose(
+ [
+ transforms.Resize((256, 256)),
+ transforms.ToTensor(),
+ transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]),
+ ]
+ )
+ self.resize_dims = (256, 256)
+
+ model_path = self.experiment_args["model_path"]
+
+ ckpt = torch.load(model_path, map_location="cpu")
+ opts = ckpt["opts"]
+ # pprint.pprint(opts) # Display full options used
+ # update the training options
+ opts["checkpoint_path"] = model_path
+ opts = Namespace(**opts)
+
+ self.net = pSp(opts)
+ self.net.eval()
+ self.net.cuda()
+
+ self.shape_predictor = dlib.shape_predictor(
+ "/content/shape_predictor_68_face_landmarks.dat"
+ )
+
+ with self.graph.as_default(), self.sess.as_default():
+ #tflib.init_tf()
+
+ self.M = Manipulator(dataset_name="ffhq", sess=self.sess)
+ self.fs3 = np.load("npy/ffhq/fs3.npy")
+ np.set_printoptions(suppress=True)
+
+ print("setup complete")
+
+ @cog.input("input", type=Path, help="Input image")
+ @cog.input("neutral", type=str, help="Neutral image description")
+ @cog.input("target", type=str, help="Target image description")
+ @cog.input(
+ "manipulation_strength",
+ type=float,
+ min=-10,
+ max=10,
+ default=4.1,
+ help="The higher the manipulation strength, the closer the generated image becomes to the target description. Negative values moves the generated image further from the target description",
+ )
+ @cog.input(
+ "disentanglement_threshold",
+ type=float,
+ min=0.08,
+ max=0.3,
+ default=0.15,
+ help="The higher the disentanglement threshold, the more specific the changes are to the target attribute. Lower values mean that broader changes are made to the input image",
+ )
+ def predict(
+ self,
+ input,
+ neutral,
+ target,
+ manipulation_strength,
+ disentanglement_threshold,
+ ):
+
+ # @title Align image
+ #original_image = Image.open(str(input))
+ #original_image = original_image.convert("RGB")
+ input_image = self.run_alignment(str(input))
+ #input_image = original_image
+ input_image = input_image.resize(self.resize_dims)
+
+ img_transforms = self.experiment_args["transform"]
+ transformed_image = img_transforms(input_image)
+
+ with torch.no_grad():
+ images, latents = self.run_on_batch(transformed_image.unsqueeze(0))
+ result_image, latent = images[0], latents[0]
+
+ print("latents", latents)
+
+ print(transformed_image.shape, result_image.shape)
+
+ w_plus = latents.cpu().detach().numpy()
+ with self.graph.as_default(), self.sess.as_default():
+ dlatents_loaded = self.M.W2S(w_plus)
+
+ #print("w_plus, dlatents_loaded", w_plus, dlatents_loaded)
+
+ img_index = 0
+ w_plus=latents.cpu().detach().numpy()
+ with self.graph.as_default(), self.sess.as_default():
+ dlatents_loaded=self.M.W2S(w_plus)
+
+ img_indexs=[img_index]
+ dlatent_tmp=[tmp[img_indexs] for tmp in dlatents_loaded]
+ with self.graph.as_default(), self.sess.as_default():
+ self.M.num_images = len(img_indexs)
+ self.M.alpha = [0]
+ self.M.manipulate_layers = [0]
+
+ with self.graph.as_default(), self.sess.as_default():
+ codes, out = self.M.EditOneC(0, dlatent_tmp)
+
+ original = Image.fromarray(out[0, 0]).resize((512, 512))
+ with self.graph.as_default(), self.sess.as_default():
+ self.M.manipulate_layers = None
+
+ classnames = [target, neutral]
+ dt = GetDt(classnames, self.model)
+
+ with self.graph.as_default(), self.sess.as_default():
+ self.M.alpha = [manipulation_strength]
+ boundary_tmp2, c = GetBoundary(
+ self.fs3, dt, self.M, threshold=disentanglement_threshold
+ )
+ codes = self.M.MSCode(dlatent_tmp, boundary_tmp2)
+ out = self.M.GenerateImg(codes)
+ generated = Image.fromarray(out[0, 0]) # .resize((512,512))
+
+ out_path = Path(tempfile.mkdtemp()) / "out.jpg"
+ generated.save(str(out_path))
+
+ return out_path
+
+ def run_alignment(self, image_path):
+ aligned_image = align_face(filepath=image_path, predictor=self.shape_predictor)
+ print("Aligned image has shape: {}".format(aligned_image.size))
+ return aligned_image
+
+ def run_on_batch(self, inputs):
+ images, latents = self.net(
+ inputs.to("cuda").float(), randomize_noise=False, return_latents=True
+ )
+ return images, latents
+
+
+def concat_images(*images):
+ width = 0
+ for im in images:
+ width += im.width
+ height = max([im.height for im in images])
+ concat = Image.new("RGB", (width, height))
+ offset = 0
+ for im in images:
+ concat.paste(im, (offset, 0))
+ offset += im.width
+ return concat
diff --git a/criteria/__init__.py b/criteria/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/criteria/clip_loss.py b/criteria/clip_loss.py
new file mode 100644
index 0000000..18176ee
--- /dev/null
+++ b/criteria/clip_loss.py
@@ -0,0 +1,17 @@
+
+import torch
+import clip
+
+
+class CLIPLoss(torch.nn.Module):
+
+ def __init__(self, opts):
+ super(CLIPLoss, self).__init__()
+ self.model, self.preprocess = clip.load("ViT-B/32", device="cuda")
+ self.upsample = torch.nn.Upsample(scale_factor=7)
+ self.avg_pool = torch.nn.AvgPool2d(kernel_size=opts.stylegan_size // 32)
+
+ def forward(self, image, text):
+ image = self.avg_pool(self.upsample(image))
+ similarity = 1 - self.model(image, text)[0] / 100
+ return similarity
\ No newline at end of file
diff --git a/criteria/id_loss.py b/criteria/id_loss.py
new file mode 100644
index 0000000..2ca3501
--- /dev/null
+++ b/criteria/id_loss.py
@@ -0,0 +1,40 @@
+import torch
+from torch import nn
+
+from models.facial_recognition.model_irse import Backbone
+
+
+class IDLoss(nn.Module):
+ def __init__(self, opts):
+ super(IDLoss, self).__init__()
+ print('Loading ResNet ArcFace')
+ self.facenet = Backbone(input_size=112, num_layers=50, drop_ratio=0.6, mode='ir_se')
+ self.facenet.load_state_dict(torch.load(opts.ir_se50_weights))
+ self.pool = torch.nn.AdaptiveAvgPool2d((256, 256))
+ self.face_pool = torch.nn.AdaptiveAvgPool2d((112, 112))
+ self.facenet.eval()
+ self.facenet.cuda()
+ self.opts = opts
+
+ def extract_feats(self, x):
+ if x.shape[2] != 256:
+ x = self.pool(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, y):
+ n_samples = y.shape[0]
+ y_feats = self.extract_feats(y) # Otherwise use the feature from there
+ y_hat_feats = self.extract_feats(y_hat)
+ y_feats = y_feats.detach()
+ loss = 0
+ sim_improvement = 0
+ count = 0
+ for i in range(n_samples):
+ diff_target = y_hat_feats[i].dot(y_feats[i])
+ loss += 1 - diff_target
+ count += 1
+
+ return loss / count, sim_improvement / count
diff --git a/global_torch/SingleChannel.py b/global_torch/SingleChannel.py
new file mode 100644
index 0000000..54b40b3
--- /dev/null
+++ b/global_torch/SingleChannel.py
@@ -0,0 +1,127 @@
+
+
+
+import numpy as np
+import torch
+
+from PIL import Image
+import copy
+from manipulate import Manipulator
+import argparse
+
+import sys
+sys.path.append('/cs/labs/danix/wuzongze/Tansformer_Manipulation/CLIP/')
+import clip
+
+def GetImgF(out,model,preprocess):
+ imgs=out
+ imgs1=imgs.reshape([-1]+list(imgs.shape[2:]))
+
+ tmp=[]
+ for i in range(len(imgs1)):
+
+ img=Image.fromarray(imgs1[i])
+ image = preprocess(img).unsqueeze(0).to(device)
+ tmp.append(image)
+
+ image=torch.cat(tmp)
+ with torch.no_grad():
+ image_features = model.encode_image(image)
+
+ image_features1=image_features.cpu().numpy()
+ image_features1=image_features1.reshape(list(imgs.shape[:2])+[512])
+
+ return image_features1
+
+def GetFs(fs):
+ tmp=np.linalg.norm(fs,axis=-1)
+ fs1=fs/tmp[:,:,:,None]
+ fs2=fs1[:,:,1,:]-fs1[:,:,0,:] # 5*sigma - (-5)* sigma
+ fs3=fs2/np.linalg.norm(fs2,axis=-1)[:,:,None]
+ fs3=fs3.mean(axis=1)
+ fs3=fs3/np.linalg.norm(fs3,axis=-1)[:,None]
+ return fs3
+
+#%%
+if __name__ == "__main__":
+ '''
+ parser = argparse.ArgumentParser(description='Process some integers.')
+
+ parser.add_argument('--dataset_name',type=str,default='cat',
+ help='name of dataset, for example, ffhq')
+ args = parser.parse_args()
+ dataset_name=args.dataset_name
+ '''
+ #%%
+ device = "cuda" if torch.cuda.is_available() else "cpu"
+ model, preprocess = clip.load("ViT-B/32", device=device,jit=False)
+ #%%
+
+ network_pkl='/cs/labs/danix/wuzongze/Gan_Manipulation/stylegan2/model/stylegan2-human-config-f.pkl'
+ device = torch.device('cuda')
+ M=Manipulator()
+ M.device=device
+ G=M.LoadModel(network_pkl,device)
+ M.G=G
+ M.SetGParameters()
+ num_img=100_000
+ M.GenerateS(num_img=num_img)
+ M.GetCodeMS()
+
+ # M=Manipulator(dataset_name=dataset_name)
+ np.set_printoptions(suppress=True)
+ # print(M.dataset_name)
+ #%%
+ img_sindex=0
+ num_images=100
+ dlatents_o=[]
+ tmp=img_sindex*num_images
+ for i in range(len(M.dlatents)):
+ tmp1=M.dlatents[i][tmp:(tmp+num_images)]
+ dlatents_o.append(tmp1)
+ #%%
+
+ all_f=[]
+ M.alpha=[-5,5] #ffhq 5
+ M.step=2
+ M.num_images=num_images
+ select=np.array(M.mindexs)<=16 #below or equal to 128 resolution
+ mindexs2=np.array(M.mindexs)[select]
+ for lindex in mindexs2: #ignore ToRGB layers
+ print(lindex)
+ num_c=M.dlatents[lindex].shape[1]
+ for cindex in range(num_c):
+
+ M.dlatents=copy.copy(dlatents_o)
+ M.dlatents[lindex][:,cindex]=M.code_mean[lindex][cindex]
+
+ M.manipulate_layers=[lindex]
+ codes,out=M.EditOneC(cindex)
+ image_features1=GetImgF(out,model,preprocess)
+ all_f.append(image_features1)
+
+ all_f=np.array(all_f)
+
+ fs3=GetFs(all_f)
+
+ #%%
+ # file_path='./npy/'+M.dataset_name+'/'
+ file_path='/cs/labs/danix/wuzongze/Gan_Manipulation/stylegan2/results/npy/human/'
+ np.save(file_path+'fs3',fs3)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/global_torch/StyleCLIP.py b/global_torch/StyleCLIP.py
new file mode 100644
index 0000000..5a97bbd
--- /dev/null
+++ b/global_torch/StyleCLIP.py
@@ -0,0 +1,246 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Jun 14 09:40:28 2022
+
+@author: wuzongze
+"""
+
+import os
+
+import sys
+import numpy as np
+import torch
+
+from PIL import Image
+import pickle
+import copy
+import matplotlib.pyplot as plt
+from manipulate import Manipulator
+
+import clip
+
+
+def SplitS(ds_p,M,if_std):
+ all_ds=[]
+ start=0
+ for i in M.mindexs:
+ tmp=M.dlatents[i].shape[1]
+ end=start+tmp
+ tmp=ds_p[start:end]
+# tmp=tmp*M.code_std[i]
+
+ all_ds.append(tmp)
+ start=end
+
+ all_ds2=[]
+ tmp_index=0
+ for i in range(len(M.s_names)):
+ if (not 'RGB' in M.s_names[i]) and (not len(all_ds[tmp_index])==0):
+
+ if if_std:
+ tmp=all_ds[tmp_index]*M.code_std[i]
+ else:
+ tmp=all_ds[tmp_index]
+
+ all_ds2.append(tmp)
+ tmp_index+=1
+ else:
+ tmp=np.zeros(len(M.dlatents[i][0]))
+ all_ds2.append(tmp)
+ return all_ds2
+
+
+imagenet_templates = [
+ 'a bad photo of a {}.',
+# 'a photo of many {}.',
+ 'a sculpture of a {}.',
+ 'a photo of the hard to see {}.',
+ 'a low resolution photo of the {}.',
+ 'a rendering of a {}.',
+ 'graffiti of a {}.',
+ 'a bad photo of the {}.',
+ 'a cropped photo of the {}.',
+ 'a tattoo of a {}.',
+ 'the embroidered {}.',
+ 'a photo of a hard to see {}.',
+ 'a bright photo of a {}.',
+ 'a photo of a clean {}.',
+ 'a photo of a dirty {}.',
+ 'a dark photo of the {}.',
+ 'a drawing of a {}.',
+ 'a photo of my {}.',
+ 'the plastic {}.',
+ 'a photo of the cool {}.',
+ 'a close-up photo of a {}.',
+ 'a black and white photo of the {}.',
+ 'a painting of the {}.',
+ 'a painting of a {}.',
+ 'a pixelated photo of the {}.',
+ 'a sculpture of the {}.',
+ 'a bright photo of the {}.',
+ 'a cropped photo of a {}.',
+ 'a plastic {}.',
+ 'a photo of the dirty {}.',
+ 'a jpeg corrupted photo of a {}.',
+ 'a blurry photo of the {}.',
+ 'a photo of the {}.',
+ 'a good photo of the {}.',
+ 'a rendering of the {}.',
+ 'a {} in a video game.',
+ 'a photo of one {}.',
+ 'a doodle of a {}.',
+ 'a close-up photo of the {}.',
+ 'a photo of a {}.',
+ 'the origami {}.',
+ 'the {} in a video game.',
+ 'a sketch of a {}.',
+ 'a doodle of the {}.',
+ 'a origami {}.',
+ 'a low resolution photo of a {}.',
+ 'the toy {}.',
+ 'a rendition of the {}.',
+ 'a photo of the clean {}.',
+ 'a photo of a large {}.',
+ 'a rendition of a {}.',
+ 'a photo of a nice {}.',
+ 'a photo of a weird {}.',
+ 'a blurry photo of a {}.',
+ 'a cartoon {}.',
+ 'art of a {}.',
+ 'a sketch of the {}.',
+ 'a embroidered {}.',
+ 'a pixelated photo of a {}.',
+ 'itap of the {}.',
+ 'a jpeg corrupted photo of the {}.',
+ 'a good photo of a {}.',
+ 'a plushie {}.',
+ 'a photo of the nice {}.',
+ 'a photo of the small {}.',
+ 'a photo of the weird {}.',
+ 'the cartoon {}.',
+ 'art of the {}.',
+ 'a drawing of the {}.',
+ 'a photo of the large {}.',
+ 'a black and white photo of a {}.',
+ 'the plushie {}.',
+ 'a dark photo of a {}.',
+ 'itap of a {}.',
+ 'graffiti of the {}.',
+ 'a toy {}.',
+ 'itap of my {}.',
+ 'a photo of a cool {}.',
+ 'a photo of a small {}.',
+ 'a tattoo of the {}.',
+]
+
+
+def zeroshot_classifier(classnames, templates,model):
+ with torch.no_grad():
+ zeroshot_weights = []
+ for classname in classnames:
+ texts = [template.format(classname) for template in templates] #format with class
+ texts = clip.tokenize(texts).cuda() #tokenize
+ class_embeddings = model.encode_text(texts) #embed with text encoder
+ class_embeddings /= class_embeddings.norm(dim=-1, keepdim=True)
+ class_embedding = class_embeddings.mean(dim=0)
+ class_embedding /= class_embedding.norm()
+ zeroshot_weights.append(class_embedding)
+ zeroshot_weights = torch.stack(zeroshot_weights, dim=1).cuda()
+ return zeroshot_weights
+
+
+def GetDt(classnames,model):
+ text_features=zeroshot_classifier(classnames, imagenet_templates,model).t()
+
+ dt=text_features[0]-text_features[1]
+ dt=dt.cpu().numpy()
+
+
+ print(np.linalg.norm(dt))
+ dt=dt/np.linalg.norm(dt)
+ return dt
+
+
+def GetBoundary(fs3,dt,M,threshold):
+ tmp=np.dot(fs3,dt)
+
+ ds_imp=copy.copy(tmp)
+ select=np.abs(tmp) Any:
+ try:
+ return self[name]
+ except KeyError:
+ raise AttributeError(name)
+
+ def __setattr__(self, name: str, value: Any) -> None:
+ self[name] = value
+
+ def __delattr__(self, name: str) -> None:
+ del self[name]
+
+
+class Logger(object):
+ """Redirect stderr to stdout, optionally print stdout to a file, and optionally force flushing on both stdout and the file."""
+
+ def __init__(self, file_name: str = None, file_mode: str = "w", should_flush: bool = True):
+ self.file = None
+
+ if file_name is not None:
+ self.file = open(file_name, file_mode)
+
+ self.should_flush = should_flush
+ self.stdout = sys.stdout
+ self.stderr = sys.stderr
+
+ sys.stdout = self
+ sys.stderr = self
+
+ def __enter__(self) -> "Logger":
+ return self
+
+ def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
+ self.close()
+
+ def write(self, text: Union[str, bytes]) -> None:
+ """Write text to stdout (and a file) and optionally flush."""
+ if isinstance(text, bytes):
+ text = text.decode()
+ if len(text) == 0: # workaround for a bug in VSCode debugger: sys.stdout.write(''); sys.stdout.flush() => crash
+ return
+
+ if self.file is not None:
+ self.file.write(text)
+
+ self.stdout.write(text)
+
+ if self.should_flush:
+ self.flush()
+
+ def flush(self) -> None:
+ """Flush written text to both stdout and a file, if open."""
+ if self.file is not None:
+ self.file.flush()
+
+ self.stdout.flush()
+
+ def close(self) -> None:
+ """Flush, close possible files, and remove stdout/stderr mirroring."""
+ self.flush()
+
+ # if using multiple loggers, prevent closing in wrong order
+ if sys.stdout is self:
+ sys.stdout = self.stdout
+ if sys.stderr is self:
+ sys.stderr = self.stderr
+
+ if self.file is not None:
+ self.file.close()
+ self.file = None
+
+
+# Cache directories
+# ------------------------------------------------------------------------------------------
+
+_dnnlib_cache_dir = None
+
+def set_cache_dir(path: str) -> None:
+ global _dnnlib_cache_dir
+ _dnnlib_cache_dir = path
+
+def make_cache_dir_path(*paths: str) -> str:
+ if _dnnlib_cache_dir is not None:
+ return os.path.join(_dnnlib_cache_dir, *paths)
+ if 'DNNLIB_CACHE_DIR' in os.environ:
+ return os.path.join(os.environ['DNNLIB_CACHE_DIR'], *paths)
+ if 'HOME' in os.environ:
+ return os.path.join(os.environ['HOME'], '.cache', 'dnnlib', *paths)
+ if 'USERPROFILE' in os.environ:
+ return os.path.join(os.environ['USERPROFILE'], '.cache', 'dnnlib', *paths)
+ return os.path.join(tempfile.gettempdir(), '.cache', 'dnnlib', *paths)
+
+# Small util functions
+# ------------------------------------------------------------------------------------------
+
+
+def format_time(seconds: Union[int, float]) -> str:
+ """Convert the seconds to human readable string with days, hours, minutes and seconds."""
+ s = int(np.rint(seconds))
+
+ if s < 60:
+ return "{0}s".format(s)
+ elif s < 60 * 60:
+ return "{0}m {1:02}s".format(s // 60, s % 60)
+ elif s < 24 * 60 * 60:
+ return "{0}h {1:02}m {2:02}s".format(s // (60 * 60), (s // 60) % 60, s % 60)
+ else:
+ return "{0}d {1:02}h {2:02}m".format(s // (24 * 60 * 60), (s // (60 * 60)) % 24, (s // 60) % 60)
+
+
+def ask_yes_no(question: str) -> bool:
+ """Ask the user the question until the user inputs a valid answer."""
+ while True:
+ try:
+ print("{0} [y/n]".format(question))
+ return strtobool(input().lower())
+ except ValueError:
+ pass
+
+
+def tuple_product(t: Tuple) -> Any:
+ """Calculate the product of the tuple elements."""
+ result = 1
+
+ for v in t:
+ result *= v
+
+ return result
+
+
+_str_to_ctype = {
+ "uint8": ctypes.c_ubyte,
+ "uint16": ctypes.c_uint16,
+ "uint32": ctypes.c_uint32,
+ "uint64": ctypes.c_uint64,
+ "int8": ctypes.c_byte,
+ "int16": ctypes.c_int16,
+ "int32": ctypes.c_int32,
+ "int64": ctypes.c_int64,
+ "float32": ctypes.c_float,
+ "float64": ctypes.c_double
+}
+
+
+def get_dtype_and_ctype(type_obj: Any) -> Tuple[np.dtype, Any]:
+ """Given a type name string (or an object having a __name__ attribute), return matching Numpy and ctypes types that have the same size in bytes."""
+ type_str = None
+
+ if isinstance(type_obj, str):
+ type_str = type_obj
+ elif hasattr(type_obj, "__name__"):
+ type_str = type_obj.__name__
+ elif hasattr(type_obj, "name"):
+ type_str = type_obj.name
+ else:
+ raise RuntimeError("Cannot infer type name from input")
+
+ assert type_str in _str_to_ctype.keys()
+
+ my_dtype = np.dtype(type_str)
+ my_ctype = _str_to_ctype[type_str]
+
+ assert my_dtype.itemsize == ctypes.sizeof(my_ctype)
+
+ return my_dtype, my_ctype
+
+
+def is_pickleable(obj: Any) -> bool:
+ try:
+ with io.BytesIO() as stream:
+ pickle.dump(obj, stream)
+ return True
+ except:
+ return False
+
+
+# Functionality to import modules/objects by name, and call functions by name
+# ------------------------------------------------------------------------------------------
+
+def get_module_from_obj_name(obj_name: str) -> Tuple[types.ModuleType, str]:
+ """Searches for the underlying module behind the name to some python object.
+ Returns the module and the object name (original name with module part removed)."""
+
+ # allow convenience shorthands, substitute them by full names
+ obj_name = re.sub("^np.", "numpy.", obj_name)
+ obj_name = re.sub("^tf.", "tensorflow.", obj_name)
+
+ # list alternatives for (module_name, local_obj_name)
+ parts = obj_name.split(".")
+ name_pairs = [(".".join(parts[:i]), ".".join(parts[i:])) for i in range(len(parts), 0, -1)]
+
+ # try each alternative in turn
+ for module_name, local_obj_name in name_pairs:
+ try:
+ module = importlib.import_module(module_name) # may raise ImportError
+ get_obj_from_module(module, local_obj_name) # may raise AttributeError
+ return module, local_obj_name
+ except:
+ pass
+
+ # maybe some of the modules themselves contain errors?
+ for module_name, _local_obj_name in name_pairs:
+ try:
+ importlib.import_module(module_name) # may raise ImportError
+ except ImportError:
+ if not str(sys.exc_info()[1]).startswith("No module named '" + module_name + "'"):
+ raise
+
+ # maybe the requested attribute is missing?
+ for module_name, local_obj_name in name_pairs:
+ try:
+ module = importlib.import_module(module_name) # may raise ImportError
+ get_obj_from_module(module, local_obj_name) # may raise AttributeError
+ except ImportError:
+ pass
+
+ # we are out of luck, but we have no idea why
+ raise ImportError(obj_name)
+
+
+def get_obj_from_module(module: types.ModuleType, obj_name: str) -> Any:
+ """Traverses the object name and returns the last (rightmost) python object."""
+ if obj_name == '':
+ return module
+ obj = module
+ for part in obj_name.split("."):
+ obj = getattr(obj, part)
+ return obj
+
+
+def get_obj_by_name(name: str) -> Any:
+ """Finds the python object with the given name."""
+ module, obj_name = get_module_from_obj_name(name)
+ return get_obj_from_module(module, obj_name)
+
+
+def call_func_by_name(*args, func_name: str = None, **kwargs) -> Any:
+ """Finds the python object with the given name and calls it as a function."""
+ assert func_name is not None
+ func_obj = get_obj_by_name(func_name)
+ assert callable(func_obj)
+ return func_obj(*args, **kwargs)
+
+
+def construct_class_by_name(*args, class_name: str = None, **kwargs) -> Any:
+ """Finds the python class with the given name and constructs it with the given arguments."""
+ return call_func_by_name(*args, func_name=class_name, **kwargs)
+
+
+def get_module_dir_by_obj_name(obj_name: str) -> str:
+ """Get the directory path of the module containing the given object name."""
+ module, _ = get_module_from_obj_name(obj_name)
+ return os.path.dirname(inspect.getfile(module))
+
+
+def is_top_level_function(obj: Any) -> bool:
+ """Determine whether the given object is a top-level function, i.e., defined at module scope using 'def'."""
+ return callable(obj) and obj.__name__ in sys.modules[obj.__module__].__dict__
+
+
+def get_top_level_function_name(obj: Any) -> str:
+ """Return the fully-qualified name of a top-level function."""
+ assert is_top_level_function(obj)
+ module = obj.__module__
+ if module == '__main__':
+ module = os.path.splitext(os.path.basename(sys.modules[module].__file__))[0]
+ return module + "." + obj.__name__
+
+
+# File system helpers
+# ------------------------------------------------------------------------------------------
+
+def list_dir_recursively_with_ignore(dir_path: str, ignores: List[str] = None, add_base_to_relative: bool = False) -> List[Tuple[str, str]]:
+ """List all files recursively in a given directory while ignoring given file and directory names.
+ Returns list of tuples containing both absolute and relative paths."""
+ assert os.path.isdir(dir_path)
+ base_name = os.path.basename(os.path.normpath(dir_path))
+
+ if ignores is None:
+ ignores = []
+
+ result = []
+
+ for root, dirs, files in os.walk(dir_path, topdown=True):
+ for ignore_ in ignores:
+ dirs_to_remove = [d for d in dirs if fnmatch.fnmatch(d, ignore_)]
+
+ # dirs need to be edited in-place
+ for d in dirs_to_remove:
+ dirs.remove(d)
+
+ files = [f for f in files if not fnmatch.fnmatch(f, ignore_)]
+
+ absolute_paths = [os.path.join(root, f) for f in files]
+ relative_paths = [os.path.relpath(p, dir_path) for p in absolute_paths]
+
+ if add_base_to_relative:
+ relative_paths = [os.path.join(base_name, p) for p in relative_paths]
+
+ assert len(absolute_paths) == len(relative_paths)
+ result += zip(absolute_paths, relative_paths)
+
+ return result
+
+
+def copy_files_and_create_dirs(files: List[Tuple[str, str]]) -> None:
+ """Takes in a list of tuples of (src, dst) paths and copies files.
+ Will create all necessary directories."""
+ for file in files:
+ target_dir_name = os.path.dirname(file[1])
+
+ # will create all intermediate-level directories
+ if not os.path.exists(target_dir_name):
+ os.makedirs(target_dir_name)
+
+ shutil.copyfile(file[0], file[1])
+
+
+# URL helpers
+# ------------------------------------------------------------------------------------------
+
+def is_url(obj: Any, allow_file_urls: bool = False) -> bool:
+ """Determine whether the given object is a valid URL string."""
+ if not isinstance(obj, str) or not "://" in obj:
+ return False
+ if allow_file_urls and obj.startswith('file://'):
+ return True
+ try:
+ res = requests.compat.urlparse(obj)
+ if not res.scheme or not res.netloc or not "." in res.netloc:
+ return False
+ res = requests.compat.urlparse(requests.compat.urljoin(obj, "/"))
+ if not res.scheme or not res.netloc or not "." in res.netloc:
+ return False
+ except:
+ return False
+ return True
+
+
+def open_url(url: str, cache_dir: str = None, num_attempts: int = 10, verbose: bool = True, return_filename: bool = False, cache: bool = True) -> Any:
+ """Download the given URL and return a binary-mode file object to access the data."""
+ assert num_attempts >= 1
+ assert not (return_filename and (not cache))
+
+ # Doesn't look like an URL scheme so interpret it as a local filename.
+ if not re.match('^[a-z]+://', url):
+ return url if return_filename else open(url, "rb")
+
+ # Handle file URLs. This code handles unusual file:// patterns that
+ # arise on Windows:
+ #
+ # file:///c:/foo.txt
+ #
+ # which would translate to a local '/c:/foo.txt' filename that's
+ # invalid. Drop the forward slash for such pathnames.
+ #
+ # If you touch this code path, you should test it on both Linux and
+ # Windows.
+ #
+ # Some internet resources suggest using urllib.request.url2pathname() but
+ # but that converts forward slashes to backslashes and this causes
+ # its own set of problems.
+ if url.startswith('file://'):
+ filename = urllib.parse.urlparse(url).path
+ if re.match(r'^/[a-zA-Z]:', filename):
+ filename = filename[1:]
+ return filename if return_filename else open(filename, "rb")
+
+ assert is_url(url)
+
+ # Lookup from cache.
+ if cache_dir is None:
+ cache_dir = make_cache_dir_path('downloads')
+
+ url_md5 = hashlib.md5(url.encode("utf-8")).hexdigest()
+ if cache:
+ cache_files = glob.glob(os.path.join(cache_dir, url_md5 + "_*"))
+ if len(cache_files) == 1:
+ filename = cache_files[0]
+ return filename if return_filename else open(filename, "rb")
+
+ # Download.
+ url_name = None
+ url_data = None
+ with requests.Session() as session:
+ if verbose:
+ print("Downloading %s ..." % url, end="", flush=True)
+ for attempts_left in reversed(range(num_attempts)):
+ try:
+ with session.get(url) as res:
+ res.raise_for_status()
+ if len(res.content) == 0:
+ raise IOError("No data received")
+
+ if len(res.content) < 8192:
+ content_str = res.content.decode("utf-8")
+ if "download_warning" in res.headers.get("Set-Cookie", ""):
+ links = [html.unescape(link) for link in content_str.split('"') if "export=download" in link]
+ if len(links) == 1:
+ url = requests.compat.urljoin(url, links[0])
+ raise IOError("Google Drive virus checker nag")
+ if "Google Drive - Quota exceeded" in content_str:
+ raise IOError("Google Drive download quota exceeded -- please try again later")
+
+ match = re.search(r'filename="([^"]*)"', res.headers.get("Content-Disposition", ""))
+ url_name = match[1] if match else url
+ url_data = res.content
+ if verbose:
+ print(" done")
+ break
+ except KeyboardInterrupt:
+ raise
+ except:
+ if not attempts_left:
+ if verbose:
+ print(" failed")
+ raise
+ if verbose:
+ print(".", end="", flush=True)
+
+ # Save to cache.
+ if cache:
+ safe_name = re.sub(r"[^0-9a-zA-Z-._]", "_", url_name)
+ cache_file = os.path.join(cache_dir, url_md5 + "_" + safe_name)
+ temp_file = os.path.join(cache_dir, "tmp_" + uuid.uuid4().hex + "_" + url_md5 + "_" + safe_name)
+ os.makedirs(cache_dir, exist_ok=True)
+ with open(temp_file, "wb") as f:
+ f.write(url_data)
+ os.replace(temp_file, cache_file) # atomic
+ if return_filename:
+ return cache_file
+
+ # Return data as file object.
+ assert not return_filename
+ return io.BytesIO(url_data)
diff --git a/global_torch/html/[6]_501_c.html b/global_torch/html/[6]_501_c.html
new file mode 100644
index 0000000..4d0740c
--- /dev/null
+++ b/global_torch/html/[6]_501_c.html
@@ -0,0 +1,99 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+ | Name |
+ Step 01 |
+
+
+
+
+ 0
|
+  |
+
+
+ 1
|
+  |
+
+
+ 2
|
+  |
+
+
+ 3
|
+  |
+
+
+ 4
|
+  |
+
+
+ 5
|
+  |
+
+
+ 6
|
+  |
+
+
+ 7
|
+  |
+
+
+ 8
|
+  |
+
+
+ 9
|
+  |
+
+
+
+
+
+
diff --git a/global_torch/html/real_.html b/global_torch/html/real_.html
new file mode 100644
index 0000000..d32725e
--- /dev/null
+++ b/global_torch/html/real_.html
@@ -0,0 +1,223 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+ | Name |
+ original |
+ man |
+ person with T-shirt |
+ person with jeans |
+ person with jacket |
+
+
+
+
+ |
+  |
+  |
+  |
+  |
+  |
+
+
+ 1
|
+  |
+  |
+  |
+  |
+  |
+
+
+ 2
|
+  |
+  |
+  |
+  |
+  |
+
+
+ 3
|
+  |
+  |
+  |
+  |
+  |
+
+
+ 4
|
+  |
+  |
+  |
+  |
+  |
+
+
+ 5
|
+  |
+  |
+  |
+  |
+  |
+
+
+ 6
|
+  |
+  |
+  |
+  |
+  |
+
+
+ 7
|
+  |
+  |
+  |
+  |
+  |
+
+
+ 8
|
+  |
+  |
+  |
+  |
+  |
+
+
+ 9
|
+  |
+  |
+  |
+  |
+  |
+
+
+ 10
|
+  |
+  |
+  |
+  |
+  |
+
+
+ 11
|
+  |
+  |
+  |
+  |
+  |
+
+
+ 12
|
+  |
+  |
+  |
+  |
+  |
+
+
+ 13
|
+  |
+  |
+  |
+  |
+  |
+
+
+ 14
|
+  |
+  |
+  |
+  |
+  |
+
+
+ 15
|
+  |
+  |
+  |
+  |
+  |
+
+
+ 16
|
+  |
+  |
+  |
+  |
+  |
+
+
+ 17
|
+  |
+  |
+  |
+  |
+  |
+
+
+ 18
|
+  |
+  |
+  |
+  |
+  |
+
+
+ 19
|
+  |
+  |
+  |
+  |
+  |
+
+
+
+
+
+
diff --git a/global_torch/legacy.py b/global_torch/legacy.py
new file mode 100644
index 0000000..f7daee7
--- /dev/null
+++ b/global_torch/legacy.py
@@ -0,0 +1,326 @@
+# Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
+#
+# NVIDIA CORPORATION and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto. Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION is strictly prohibited.
+
+import click
+import pickle
+import re
+import copy
+import numpy as np
+import torch
+import dnnlib
+from torch_utils import misc
+
+#----------------------------------------------------------------------------
+
+def load_network_pkl(f, force_fp16=False):
+ data = _LegacyUnpickler(f).load()
+
+ # Legacy TensorFlow pickle => convert.
+ if isinstance(data, tuple) and len(data) == 3 and all(isinstance(net, _TFNetworkStub) for net in data):
+ tf_G, tf_D, tf_Gs = data
+ G = convert_tf_generator(tf_G)
+ D = convert_tf_discriminator(tf_D)
+ G_ema = convert_tf_generator(tf_Gs)
+ data = dict(G=G, D=D, G_ema=G_ema)
+
+ # Add missing fields.
+ if 'training_set_kwargs' not in data:
+ data['training_set_kwargs'] = None
+ if 'augment_pipe' not in data:
+ data['augment_pipe'] = None
+
+ # Validate contents.
+ assert isinstance(data['G'], torch.nn.Module)
+ assert isinstance(data['D'], torch.nn.Module)
+ assert isinstance(data['G_ema'], torch.nn.Module)
+ assert isinstance(data['training_set_kwargs'], (dict, type(None)))
+ assert isinstance(data['augment_pipe'], (torch.nn.Module, type(None)))
+
+ # Force FP16.
+ if force_fp16:
+ for key in ['G', 'D', 'G_ema']:
+ old = data[key]
+ kwargs = copy.deepcopy(old.init_kwargs)
+ if key.startswith('G'):
+ kwargs.synthesis_kwargs = dnnlib.EasyDict(kwargs.get('synthesis_kwargs', {}))
+ kwargs.synthesis_kwargs.num_fp16_res = 4
+ kwargs.synthesis_kwargs.conv_clamp = 256
+ if key.startswith('D'):
+ kwargs.num_fp16_res = 4
+ kwargs.conv_clamp = 256
+ if kwargs != old.init_kwargs:
+ new = type(old)(**kwargs).eval().requires_grad_(False)
+ misc.copy_params_and_buffers(old, new, require_all=True)
+ data[key] = new
+ return data
+
+#----------------------------------------------------------------------------
+
+class _TFNetworkStub(dnnlib.EasyDict):
+ pass
+
+class _LegacyUnpickler(pickle.Unpickler):
+ def find_class(self, module, name):
+ if module == 'dnnlib.tflib.network' and name == 'Network':
+ return _TFNetworkStub
+ return super().find_class(module, name)
+
+#----------------------------------------------------------------------------
+
+def _collect_tf_params(tf_net):
+ # pylint: disable=protected-access
+ tf_params = dict()
+ def recurse(prefix, tf_net):
+ for name, value in tf_net.variables:
+ tf_params[prefix + name] = value
+ for name, comp in tf_net.components.items():
+ recurse(prefix + name + '/', comp)
+ recurse('', tf_net)
+ return tf_params
+
+#----------------------------------------------------------------------------
+
+def _populate_module_params(module, *patterns):
+ for name, tensor in misc.named_params_and_buffers(module):
+ found = False
+ value = None
+ for pattern, value_fn in zip(patterns[0::2], patterns[1::2]):
+ match = re.fullmatch(pattern, name)
+ if match:
+ found = True
+ if value_fn is not None:
+ value = value_fn(*match.groups())
+ break
+ try:
+ assert found
+ if value is not None:
+ tensor.copy_(torch.from_numpy(np.array(value)))
+ except:
+ print(name, list(tensor.shape))
+ raise
+
+#----------------------------------------------------------------------------
+
+def convert_tf_generator(tf_G):
+ if tf_G.version < 4:
+ raise ValueError('TensorFlow pickle version too low')
+
+ # Collect kwargs.
+ tf_kwargs = tf_G.static_kwargs
+ known_kwargs = set()
+ def kwarg(tf_name, default=None, none=None):
+ known_kwargs.add(tf_name)
+ val = tf_kwargs.get(tf_name, default)
+ return val if val is not None else none
+
+ # Convert kwargs.
+ kwargs = dnnlib.EasyDict(
+ z_dim = kwarg('latent_size', 512),
+ c_dim = kwarg('label_size', 0),
+ w_dim = kwarg('dlatent_size', 512),
+ img_resolution = kwarg('resolution', 1024),
+ img_channels = kwarg('num_channels', 3),
+ mapping_kwargs = dnnlib.EasyDict(
+ num_layers = kwarg('mapping_layers', 8),
+ embed_features = kwarg('label_fmaps', None),
+ layer_features = kwarg('mapping_fmaps', None),
+ activation = kwarg('mapping_nonlinearity', 'lrelu'),
+ lr_multiplier = kwarg('mapping_lrmul', 0.01),
+ w_avg_beta = kwarg('w_avg_beta', 0.995, none=1),
+ ),
+ synthesis_kwargs = dnnlib.EasyDict(
+ channel_base = kwarg('fmap_base', 16384) * 2,
+ channel_max = kwarg('fmap_max', 512),
+ num_fp16_res = kwarg('num_fp16_res', 0),
+ conv_clamp = kwarg('conv_clamp', None),
+ architecture = kwarg('architecture', 'skip'),
+ resample_filter = kwarg('resample_kernel', [1,3,3,1]),
+ use_noise = kwarg('use_noise', True),
+ activation = kwarg('nonlinearity', 'lrelu'),
+ ),
+ )
+
+ # Check for unknown kwargs.
+ kwarg('truncation_psi')
+ kwarg('truncation_cutoff')
+ kwarg('style_mixing_prob')
+ kwarg('structure')
+ if 'resolution_w' in tf_kwargs:
+ tf_kwargs.pop('resolution_w', None)
+ tf_kwargs.pop('resolution_h', None)
+ unknown_kwargs = list(set(tf_kwargs.keys()) - known_kwargs)
+ if len(unknown_kwargs) > 0:
+ raise ValueError('Unknown TensorFlow kwarg', unknown_kwargs[0])
+
+ # Collect params.
+ tf_params = _collect_tf_params(tf_G)
+ for name, value in list(tf_params.items()):
+ match = re.fullmatch(r'ToRGB_lod(\d+)/(.*)', name)
+ if match:
+ r = kwargs.img_resolution // (2 ** int(match.group(1)))
+ tf_params[f'{r}x{r}/ToRGB/{match.group(2)}'] = value
+ kwargs.synthesis.kwargs.architecture = 'orig'
+ #for name, value in tf_params.items(): print(f'{name:<50s}{list(value.shape)}')
+
+ # Convert params.
+ from training import networks
+ G = networks.Generator(**kwargs).eval().requires_grad_(False)
+ # pylint: disable=unnecessary-lambda
+ _populate_module_params(G,
+ r'mapping\.w_avg', lambda: tf_params[f'dlatent_avg'],
+ r'mapping\.embed\.weight', lambda: tf_params[f'mapping/LabelEmbed/weight'].transpose(),
+ r'mapping\.embed\.bias', lambda: tf_params[f'mapping/LabelEmbed/bias'],
+ r'mapping\.fc(\d+)\.weight', lambda i: tf_params[f'mapping/Dense{i}/weight'].transpose(),
+ r'mapping\.fc(\d+)\.bias', lambda i: tf_params[f'mapping/Dense{i}/bias'],
+ r'synthesis\.b4\.const', lambda: tf_params[f'synthesis/4x4/Const/const'][0],
+ r'synthesis\.b4\.conv1\.weight', lambda: tf_params[f'synthesis/4x4/Conv/weight'].transpose(3, 2, 0, 1),
+ r'synthesis\.b4\.conv1\.bias', lambda: tf_params[f'synthesis/4x4/Conv/bias'],
+ r'synthesis\.b4\.conv1\.noise_const', lambda: tf_params[f'synthesis/noise0'][0, 0],
+ r'synthesis\.b4\.conv1\.noise_strength', lambda: tf_params[f'synthesis/4x4/Conv/noise_strength'],
+ r'synthesis\.b4\.conv1\.affine\.weight', lambda: tf_params[f'synthesis/4x4/Conv/mod_weight'].transpose(),
+ r'synthesis\.b4\.conv1\.affine\.bias', lambda: tf_params[f'synthesis/4x4/Conv/mod_bias'] + 1,
+ r'synthesis\.b(\d+)\.conv0\.weight', lambda r: tf_params[f'synthesis/{r}x{r}/Conv0_up/weight'][::-1, ::-1].transpose(3, 2, 0, 1),
+ r'synthesis\.b(\d+)\.conv0\.bias', lambda r: tf_params[f'synthesis/{r}x{r}/Conv0_up/bias'],
+ r'synthesis\.b(\d+)\.conv0\.noise_const', lambda r: tf_params[f'synthesis/noise{int(np.log2(int(r)))*2-5}'][0, 0],
+ r'synthesis\.b(\d+)\.conv0\.noise_strength', lambda r: tf_params[f'synthesis/{r}x{r}/Conv0_up/noise_strength'],
+ r'synthesis\.b(\d+)\.conv0\.affine\.weight', lambda r: tf_params[f'synthesis/{r}x{r}/Conv0_up/mod_weight'].transpose(),
+ r'synthesis\.b(\d+)\.conv0\.affine\.bias', lambda r: tf_params[f'synthesis/{r}x{r}/Conv0_up/mod_bias'] + 1,
+ r'synthesis\.b(\d+)\.conv1\.weight', lambda r: tf_params[f'synthesis/{r}x{r}/Conv1/weight'].transpose(3, 2, 0, 1),
+ r'synthesis\.b(\d+)\.conv1\.bias', lambda r: tf_params[f'synthesis/{r}x{r}/Conv1/bias'],
+ r'synthesis\.b(\d+)\.conv1\.noise_const', lambda r: tf_params[f'synthesis/noise{int(np.log2(int(r)))*2-4}'][0, 0],
+ r'synthesis\.b(\d+)\.conv1\.noise_strength', lambda r: tf_params[f'synthesis/{r}x{r}/Conv1/noise_strength'],
+ r'synthesis\.b(\d+)\.conv1\.affine\.weight', lambda r: tf_params[f'synthesis/{r}x{r}/Conv1/mod_weight'].transpose(),
+ r'synthesis\.b(\d+)\.conv1\.affine\.bias', lambda r: tf_params[f'synthesis/{r}x{r}/Conv1/mod_bias'] + 1,
+ r'synthesis\.b(\d+)\.torgb\.weight', lambda r: tf_params[f'synthesis/{r}x{r}/ToRGB/weight'].transpose(3, 2, 0, 1),
+ r'synthesis\.b(\d+)\.torgb\.bias', lambda r: tf_params[f'synthesis/{r}x{r}/ToRGB/bias'],
+ r'synthesis\.b(\d+)\.torgb\.affine\.weight', lambda r: tf_params[f'synthesis/{r}x{r}/ToRGB/mod_weight'].transpose(),
+ r'synthesis\.b(\d+)\.torgb\.affine\.bias', lambda r: tf_params[f'synthesis/{r}x{r}/ToRGB/mod_bias'] + 1,
+ r'synthesis\.b(\d+)\.skip\.weight', lambda r: tf_params[f'synthesis/{r}x{r}/Skip/weight'][::-1, ::-1].transpose(3, 2, 0, 1),
+ r'.*\.resample_filter', None,
+ )
+ return G
+
+#----------------------------------------------------------------------------
+
+def convert_tf_discriminator(tf_D):
+ if tf_D.version < 4:
+ raise ValueError('TensorFlow pickle version too low')
+
+ # Collect kwargs.
+ tf_kwargs = tf_D.static_kwargs
+ known_kwargs = set()
+ def kwarg(tf_name, default=None):
+ known_kwargs.add(tf_name)
+ return tf_kwargs.get(tf_name, default)
+
+ # Convert kwargs.
+ kwargs = dnnlib.EasyDict(
+ c_dim = kwarg('label_size', 0),
+ img_resolution = kwarg('resolution', 1024),
+ img_channels = kwarg('num_channels', 3),
+ architecture = kwarg('architecture', 'resnet'),
+ channel_base = kwarg('fmap_base', 16384) * 2,
+ channel_max = kwarg('fmap_max', 512),
+ num_fp16_res = kwarg('num_fp16_res', 0),
+ conv_clamp = kwarg('conv_clamp', None),
+ cmap_dim = kwarg('mapping_fmaps', None),
+ block_kwargs = dnnlib.EasyDict(
+ activation = kwarg('nonlinearity', 'lrelu'),
+ resample_filter = kwarg('resample_kernel', [1,3,3,1]),
+ freeze_layers = kwarg('freeze_layers', 0),
+ ),
+ mapping_kwargs = dnnlib.EasyDict(
+ num_layers = kwarg('mapping_layers', 0),
+ embed_features = kwarg('mapping_fmaps', None),
+ layer_features = kwarg('mapping_fmaps', None),
+ activation = kwarg('nonlinearity', 'lrelu'),
+ lr_multiplier = kwarg('mapping_lrmul', 0.1),
+ ),
+ epilogue_kwargs = dnnlib.EasyDict(
+ mbstd_group_size = kwarg('mbstd_group_size', None),
+ mbstd_num_channels = kwarg('mbstd_num_features', 1),
+ activation = kwarg('nonlinearity', 'lrelu'),
+ ),
+ )
+
+ # Check for unknown kwargs.
+ kwarg('structure')
+ if 'resolution_w' in tf_kwargs:
+ tf_kwargs.pop('resolution_w', None)
+ tf_kwargs.pop('resolution_h', None)
+ unknown_kwargs = list(set(tf_kwargs.keys()) - known_kwargs)
+ if len(unknown_kwargs) > 0:
+ raise ValueError('Unknown TensorFlow kwarg', unknown_kwargs[0])
+
+ # Collect params.
+ tf_params = _collect_tf_params(tf_D)
+ for name, value in list(tf_params.items()):
+ match = re.fullmatch(r'FromRGB_lod(\d+)/(.*)', name)
+ if match:
+ r = kwargs.img_resolution // (2 ** int(match.group(1)))
+ tf_params[f'{r}x{r}/FromRGB/{match.group(2)}'] = value
+ kwargs.architecture = 'orig'
+ #for name, value in tf_params.items(): print(f'{name:<50s}{list(value.shape)}')
+
+ # Convert params.
+ from training import networks
+ D = networks.Discriminator(**kwargs).eval().requires_grad_(False)
+ # pylint: disable=unnecessary-lambda
+ _populate_module_params(D,
+ r'b(\d+)\.fromrgb\.weight', lambda r: tf_params[f'{r}x{r}/FromRGB/weight'].transpose(3, 2, 0, 1),
+ r'b(\d+)\.fromrgb\.bias', lambda r: tf_params[f'{r}x{r}/FromRGB/bias'],
+ r'b(\d+)\.conv(\d+)\.weight', lambda r, i: tf_params[f'{r}x{r}/Conv{i}{["","_down"][int(i)]}/weight'].transpose(3, 2, 0, 1),
+ r'b(\d+)\.conv(\d+)\.bias', lambda r, i: tf_params[f'{r}x{r}/Conv{i}{["","_down"][int(i)]}/bias'],
+ r'b(\d+)\.skip\.weight', lambda r: tf_params[f'{r}x{r}/Skip/weight'].transpose(3, 2, 0, 1),
+ r'mapping\.embed\.weight', lambda: tf_params[f'LabelEmbed/weight'].transpose(),
+ r'mapping\.embed\.bias', lambda: tf_params[f'LabelEmbed/bias'],
+ r'mapping\.fc(\d+)\.weight', lambda i: tf_params[f'Mapping{i}/weight'].transpose(),
+ r'mapping\.fc(\d+)\.bias', lambda i: tf_params[f'Mapping{i}/bias'],
+ r'b4\.conv\.weight', lambda: tf_params[f'4x4/Conv/weight'].transpose(3, 2, 0, 1),
+ r'b4\.conv\.bias', lambda: tf_params[f'4x4/Conv/bias'],
+ r'b4\.fc\.weight', lambda: tf_params[f'4x4/Dense0/weight'].transpose(),
+ r'b4\.fc\.bias', lambda: tf_params[f'4x4/Dense0/bias'],
+ r'b4\.out\.weight', lambda: tf_params[f'Output/weight'].transpose(),
+ r'b4\.out\.bias', lambda: tf_params[f'Output/bias'],
+ r'.*\.resample_filter', None,
+ )
+ return D
+
+#----------------------------------------------------------------------------
+
+@click.command()
+@click.option('--source', help='Input pickle', required=True, metavar='PATH')
+@click.option('--dest', help='Output pickle', required=True, metavar='PATH')
+@click.option('--force-fp16', help='Force the networks to use FP16', type=bool, default=False, metavar='BOOL', show_default=True)
+def convert_network_pickle(source, dest, force_fp16):
+ """Convert legacy network pickle into the native PyTorch format.
+
+ The tool is able to load the main network configurations exported using the TensorFlow version of StyleGAN2 or StyleGAN2-ADA.
+ It does not support e.g. StyleGAN2-ADA comparison methods, StyleGAN2 configs A-D, or StyleGAN1 networks.
+
+ Example:
+
+ \b
+ python legacy.py \\
+ --source=https://nvlabs-fi-cdn.nvidia.com/stylegan2/networks/stylegan2-cat-config-f.pkl \\
+ --dest=stylegan2-cat-config-f.pkl
+ """
+ print(f'Loading "{source}"...')
+ with dnnlib.util.open_url(source) as f:
+ data = load_network_pkl(f, force_fp16=force_fp16)
+ print(f'Saving "{dest}"...')
+ with open(dest, 'wb') as f:
+ pickle.dump(data, f)
+ print('Done.')
+
+#----------------------------------------------------------------------------
+
+if __name__ == "__main__":
+ convert_network_pickle() # pylint: disable=no-value-for-parameter
+
+#----------------------------------------------------------------------------
diff --git a/global_torch/manipulate.py b/global_torch/manipulate.py
new file mode 100644
index 0000000..cc40ffc
--- /dev/null
+++ b/global_torch/manipulate.py
@@ -0,0 +1,383 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Jul 19 21:03:58 2021
+
+@author: wuzongze
+"""
+
+
+import sys
+
+import copy
+import os
+from time import perf_counter
+
+import click
+import imageio
+import numpy as np
+import PIL.Image
+import torch
+import torch.nn.functional as F
+from PIL import Image
+
+import dnnlib
+import legacy
+import pickle
+from visualizer import HtmlPageVisualizer
+
+from torch_utils import misc
+import types
+from training.networks import SynthesisNetwork,SynthesisBlock,SynthesisLayer,ToRGBLayer
+
+
+def change_style_code(codes, layer, channel, step):
+ codes[layer][:, channel] += step
+ return codes
+
+def Vis(bname,suffix,out,rownames=None,colnames=None,save_path=None,viz_size=256):
+
+ if save_path is None:
+ save_path='./html/'
+
+
+ num_images=out.shape[0]
+ step=out.shape[1]
+
+ if colnames is None:
+ colnames=[f'Step {i:02d}' for i in range(1, step + 1)]
+ if rownames is None:
+ rownames=[str(i) for i in range(num_images)]
+
+
+ visualizer = HtmlPageVisualizer(
+ num_rows=num_images, num_cols=step + 1, viz_size=viz_size)
+ visualizer.set_headers(
+ ['Name'] +colnames)
+
+ for i in range(num_images):
+ visualizer.set_cell(i, 0, text=rownames[i])
+
+ for i in range(num_images):
+ for k in range(step):
+ image=out[i,k,:,:,:]
+ visualizer.set_cell(i, 1+k, image=image)
+
+ visualizer.save(save_path+bname+'_'+suffix+'.html')
+
+def LoadModel(network_pkl,device):
+ with dnnlib.util.open_url(network_pkl) as fp:
+ G = legacy.load_network_pkl(fp)['G_ema'].requires_grad_(False).to(device) # type: ignore
+
+ G.synthesis.forward=types.MethodType(SynthesisNetwork.forward,G.synthesis)
+ G.synthesis.W2S=types.MethodType(SynthesisNetwork.W2S,G.synthesis)
+
+ for res in G.synthesis.block_resolutions:
+ block = getattr(G.synthesis, f'b{res}')
+ # print(block)
+ block.forward=types.MethodType(SynthesisBlock.forward,block)
+
+ if res!=4:
+ layer=block.conv0
+ layer.forward=types.MethodType(SynthesisLayer.forward,layer)
+ layer.name='conv0_resolution_'+str(res)
+
+ layer=block.conv1
+ layer.forward=types.MethodType(SynthesisLayer.forward,layer)
+ layer.name='conv1_resolution_'+str(res)
+
+ layer=block.torgb
+ layer.forward=types.MethodType(ToRGBLayer.forward,layer)
+ layer.name='toRGB_resolution_'+str(res)
+
+
+ return G
+
+
+def S2List(encoded_styles):
+ all_s=[]
+ for name in encoded_styles.keys():
+ tmp=encoded_styles[name].cpu().numpy()
+ all_s.append(tmp)
+ return all_s
+
+
+
+class Manipulator():
+ def __init__(self,dataset_name='ffhq'):
+
+ self.alpha=[0] #manipulation strength
+ self.num_images=10
+ self.img_index=0 #which image to start
+ # self.viz_size=256
+ self.manipulate_layers=None #which layer to manipulate, list
+ self.truncation_psi=0.7
+ self.truncation_cutoff=8
+
+# self.G=LoadModel(self.model_path,self.model_name)
+
+ self.LoadModel=LoadModel
+ self.Vis=Vis
+ self.S2List=S2List
+
+ fmaps=[512, 512, 512, 512, 512, 256, 128, 64, 32]
+ self.fmaps=np.repeat(fmaps,3)
+
+
+ def GetSName(self):
+ s_names=[]
+ for res in self.G.synthesis.block_resolutions:
+ if res==4:
+ tmp=f'conv1_resolution_{res}'
+ s_names.append(tmp)
+
+ tmp=f'toRGB_resolution_{res}'
+ s_names.append(tmp)
+ else:
+ tmp=f'conv0_resolution_{res}'
+ s_names.append(tmp)
+
+ tmp=f'conv1_resolution_{res}'
+ s_names.append(tmp)
+
+ tmp=f'toRGB_resolution_{res}'
+ s_names.append(tmp)
+
+ return s_names
+
+ def SL2D(self,tmp_code):
+ encoded_styles={}
+ for i in range(len(self.s_names)):
+ encoded_styles[self.s_names[i]]=torch.from_numpy(tmp_code[i]).to(self.device)
+
+ return encoded_styles
+
+
+
+ def GenerateS(self,num_img=100):
+ seed=5
+ with torch.no_grad():
+ z = torch.from_numpy(np.random.RandomState(seed).randn(num_img, self.G.z_dim)).to(self.device)
+ ws = self.G.mapping(z=z,c=None,truncation_psi=self.truncation_psi,truncation_cutoff=self.truncation_cutoff)
+ encoded_styles=self.G.synthesis.W2S(ws)
+# encoded_styles=encoded_styles.cpu().numpy()
+
+ self.dlatents=S2List(encoded_styles)
+
+ def GenerateImg(self,codes):
+
+ num_images,step=codes[0].shape[:2]
+ out=np.zeros((num_images,step,self.img_size,self.img_size,3),dtype='uint8')
+ for i in range(num_images):
+ for k in range(step):
+
+ tmp_code=[]
+ for m in range(len(self.s_names)):
+ tmp=codes[m][i,k][None,:]
+ tmp_code.append(tmp)
+
+ encoded_styles=self.SL2D(tmp_code)
+
+ with torch.no_grad():
+ img = self.G.synthesis(None, encoded_styles=encoded_styles,noise_mode='const')
+ img = (img + 1) * (255/2)
+ img = img.permute(0, 2, 3, 1).clamp(0, 255).to(torch.uint8)[0].cpu().numpy()
+
+
+
+ if img.shape[1]==img.shape[0]:
+ out[i,k,:,:,:]=img
+ else:
+ tmp=img.shape[1]
+ tmp1=int((img.shape[0]-tmp)/2)
+ out[i,k,:,tmp1:tmp1+tmp,:]=img
+ return out
+
+ def ShowImg(self,num_img=10):
+
+ codes=[]
+ for i in range(len(self.dlatents)):
+ # print(i)
+ tmp=self.dlatents[i][:num_img,None,:]
+ codes.append(tmp)
+ out=self.GenerateImg(codes)
+ return out
+
+ def SetGParameters(self):
+ self.num_layers=self.G.synthesis.num_ws
+ self.img_size=self.G.synthesis.img_resolution
+ self.s_names=self.GetSName()
+
+ self.img_size=self.G.synthesis.block_resolutions[-1]
+
+ self.mindexs=[0, 2, 3, 5, 6, 8, 9, 11, 12, 14, 15, 17, 18, 20, 21,23,24]
+
+
+
+ def MSCode(self,dlatent_tmp,boundary_tmp):
+
+ step=len(self.alpha)
+ dlatent_tmp1=[tmp.reshape((self.num_images,-1)) for tmp in dlatent_tmp]
+ dlatent_tmp2=[np.tile(tmp[:,None],(1,step,1)) for tmp in dlatent_tmp1] # (10, 7, 512)
+
+ l=np.array(self.alpha)
+ l=l.reshape(
+ [step if axis == 1 else 1 for axis in range(dlatent_tmp2[0].ndim)])
+
+ if type(self.manipulate_layers)==int:
+ tmp=[self.manipulate_layers]
+ elif type(self.manipulate_layers)==list:
+ tmp=self.manipulate_layers
+ elif self.manipulate_layers is None:
+ tmp=np.arange(len(boundary_tmp))
+ else:
+ raise ValueError('manipulate_layers is wrong')
+
+ for i in tmp:
+ dlatent_tmp2[i]+=l*boundary_tmp[i]
+
+ codes=[]
+ for i in range(len(dlatent_tmp2)):
+ tmp=list(dlatent_tmp[i].shape)
+ tmp.insert(1,step)
+ codes.append(dlatent_tmp2[i].reshape(tmp))
+ return codes
+
+
+ def EditOne(self,bname,dlatent_tmp=None):
+ if dlatent_tmp==None:
+ dlatent_tmp=[tmp[self.img_index:(self.img_index+self.num_images)] for tmp in self.dlatents]
+
+ boundary_tmp=[]
+ for i in range(len(self.boundary)):
+ tmp=self.boundary[i]
+ if len(tmp)<=bname:
+ boundary_tmp.append([])
+ else:
+ boundary_tmp.append(tmp[bname])
+
+ codes=self.MSCode(dlatent_tmp,boundary_tmp)
+
+ out=self.GenerateImg(codes)
+ return codes,out
+
+ def EditOneC(self,cindex,dlatent_tmp=None):
+ if dlatent_tmp==None:
+ dlatent_tmp=[tmp[self.img_index:(self.img_index+self.num_images)] for tmp in self.dlatents]
+
+ boundary_tmp=[[] for i in range(len(self.dlatents))]
+
+ #'only manipulate 1 layer and one channel'
+ assert len(self.manipulate_layers)==1
+
+ ml=self.manipulate_layers[0]
+ tmp=dlatent_tmp[ml].shape[1] #ada
+ tmp1=np.zeros(tmp)
+ tmp1[cindex]=self.code_std[ml][cindex] #1
+ boundary_tmp[ml]=tmp1
+
+ codes=self.MSCode(dlatent_tmp,boundary_tmp)
+ out=self.GenerateImg(codes)
+ return codes,out
+
+ def GetFindex(self,lindex,cindex,ignore_RGB=False):
+
+ if ignore_RGB:
+ tmp=np.array(self.mindexs)0]
+ lindex=len(tmp)
+ if lindex==0:
+ cindex=tmp_index
+ else:
+ cindex=tmp[-1]
+
+ if cindex ==self.fmaps[lindex]:
+ cindex=0
+ lindex+=1
+ # print(completeness.index[i],completeness.iloc[i,:].values,lindex,cindex)
+ l_p.append([lindex,cindex])
+ l_p=np.array(l_p)
+ return l_p
+ def GetLCIndex2(self,findex): #input findex without ToRGB
+ fmaps_o=copy.copy(self.fmaps)
+ mindexs=[0, 2, 3, 5, 6, 8, 9, 11, 12, 14, 15, 17, 18, 20, 21,23,24]
+ self.fmaps=fmaps_o[mindexs]
+
+ l_p=self.GetLCIndex(findex)
+
+ l=l_p[:,0]
+ l2=np.array(mindexs)[l]
+ l_p[:,0]=l2
+ self.fmaps=fmaps_o
+ return l_p
+
+ def GetCodeMS(self):
+ m=[]
+ std=[]
+ for i in range(len(self.dlatents)):
+ tmp= self.dlatents[i]
+ tmp_mean=tmp.mean(axis=0)
+ tmp_std=tmp.std(axis=0)
+ m.append(tmp_mean)
+ std.append(tmp_std)
+
+ self.code_mean=m
+ self.code_std=std
+ # return m,std
+
+
+#%%
+if __name__ == "__main__":
+ network_pkl='/cs/labs/danix/wuzongze/Gan_Manipulation/stylegan2/model/stylegan2-ffhq-config-f.pkl'
+ device = torch.device('cuda')
+ M=Manipulator()
+ M.device=device
+ G=M.LoadModel(network_pkl,device)
+ M.G=G
+ M.SetGParameters()
+ num_img=100_000
+ M.GenerateS(num_img=num_img)
+ M.GetCodeMS()
+ np.set_printoptions(suppress=True)
+
+ #%%
+ M.alpha=[24,16,8,0,-8,-16,-24]
+ M.step=len(M.alpha)
+ M.img_index=0
+ M.num_images=10
+ lindex,bname=6,501
+# M.
+ M.manipulate_layers=[lindex]
+ codes,out=M.EditOneC(bname) #dlatent_tmp
+ tmp=str(M.manipulate_layers)+'_'+str(bname)
+ M.Vis(tmp,'c',out)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/global_torch/npy/ffhq/fs3.npy b/global_torch/npy/ffhq/fs3.npy
new file mode 100644
index 0000000000000000000000000000000000000000..ef9dc0a49a4e2ffe1c81b8632baab6e3a4466726
GIT binary patch
literal 6193280
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