diff --git a/.gitattributes b/.gitattributes index c7d9f3332a950355d5a77d85000f05e6f45435ea..553c56aca0c235d9eedaf549083df925a158cea8 100644 --- a/.gitattributes +++ b/.gitattributes @@ -32,3 +32,9 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text *.zip filter=lfs diff=lfs merge=lfs -text *.zst filter=lfs diff=lfs merge=lfs -text *tfevents* filter=lfs diff=lfs merge=lfs -text +deps/windows/glumpy-1.1.0-cp37-cp37m-win_amd64.whl filter=lfs diff=lfs merge=lfs -text +deps/windows/PyOpenGL-3.1.4-cp37-cp37m-win_amd64.whl filter=lfs diff=lfs merge=lfs -text +deps/windows/triangle-20190115.3-cp37-cp37m-win_amd64.whl filter=lfs diff=lfs merge=lfs -text +models/stylegan/stylegan_tf/stylegan-teaser.png filter=lfs diff=lfs merge=lfs -text +models/stylegan2/stylegan2-pytorch/doc/sample.png filter=lfs diff=lfs merge=lfs -text +models/stylegan2/stylegan2-pytorch/doc/stylegan2-church-config-f.png filter=lfs diff=lfs merge=lfs -text diff --git a/FashionGen.py b/FashionGen.py new file mode 100644 index 0000000000000000000000000000000000000000..586d867eb116d5cb45e059a86ec3926eb752a827 --- /dev/null +++ b/FashionGen.py @@ -0,0 +1,265 @@ +import random +import streamlit as st +import torch +import PIL +import numpy as np +from PIL import Image +import imageio +from models import get_instrumented_model +from decomposition import get_or_compute +from config import Config +from skimage import img_as_ubyte +import clip +from torchvision.transforms import Resize, Normalize, Compose, CenterCrop +from torch.optim import Adam +from stqdm import stqdm + +torch.set_num_threads(8) + +# Speed up computation +torch.autograd.set_grad_enabled(True) +#torch.backends.cudnn.benchmark = True + +# Specify model to use +config = Config( + model='StyleGAN2', + layer='style', + output_class= 'lookbook', + components=80, + use_w=True, + batch_size=5_000, # style layer quite small +) + +device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + +preprocess = Compose([ + Resize(224), + CenterCrop(224), + Normalize(mean=(0.48145466, 0.4578275, 0.40821073), std=(0.26862954, 0.26130258, 0.27577711)), +]) + +@st.cache_data +def clip_optimized_latent(text, seed, iterations=25, lr=1e-2): + seed = int(seed) + text_input = clip.tokenize([text]).to(device) + + # Initialize a random latent vector + latent_vector = model.sample_latent(1,seed=seed).detach() + latent_vector.requires_grad = True + latent_vector = [latent_vector]*model.get_max_latents() + params = [torch.nn.Parameter(latent_vector[i], requires_grad=True) for i in range(len(latent_vector))] + optimizer = Adam(params, lr=lr) + + with torch.no_grad(): + text_features = clip_model.encode_text(text_input) + + #pbar = tqdm(range(iterations), dynamic_ncols=True) + + for iteration in stqdm(range(iterations)): + optimizer.zero_grad() + + # Generate an image from the latent vector + image = model.sample(params) + image = image.to(device) + + # Preprocess the image for the CLIP model + image = preprocess(image) + #image = clip_preprocess(Image.fromarray((image_np * 255).astype(np.uint8))).unsqueeze(0).to(device) + + # Extract features from the image + image_features = clip_model.encode_image(image) + + # Calculate the loss and backpropagate + loss = -torch.cosine_similarity(text_features, image_features).mean() + loss.backward() + optimizer.step() + + #pbar.set_description(f"Loss: {loss.item()}") # Update the progress bar to show the current loss + w = [param.detach().cpu().numpy() for param in params] + + return w + +def mix_w(w1, w2, content, style): + for i in range(0,5): + w2[i] = w1[i] * (1 - content) + w2[i] * content + + for i in range(5, 16): + w2[i] = w1[i] * (1 - style) + w2[i] * style + + return w2 + +def display_sample_pytorch(seed, truncation, directions, distances, scale, start, end, w=None, disp=True, save=None, noise_spec=None): + # blockPrint() + model.truncation = truncation + if w is None: + w = model.sample_latent(1, seed=seed).detach().cpu().numpy() + w = [w]*model.get_max_latents() # one per layer + else: + w_numpy = [x.detach().numpy() for x in w] + w = [np.expand_dims(x, 0) for x in w_numpy] + #w = [x.unsqueeze(0) for x in w] + + + for l in range(start, end): + for i in range(len(directions)): + w[l] = w[l] + directions[i] * distances[i] * scale + + torch.cuda.empty_cache() + #save image and display + out = model.sample(w) + out = out.permute(0, 2, 3, 1).cpu().detach().numpy() + out = np.clip(out, 0.0, 1.0).squeeze() + + final_im = Image.fromarray((out * 255).astype(np.uint8)).resize((500,500),Image.LANCZOS) + + + if save is not None: + if disp == False: + print(save) + final_im.save(f'out/{seed}_{save:05}.png') + if disp: + display(final_im) + + return final_im + +## Generate image for app +def generate_image(content, style, truncation, c0, c1, c2, c3, c4, c5, c6, start_layer, end_layer,w1,w2): + + scale = 1 + params = {'c0': c0, + 'c1': c1, + 'c2': c2, + 'c3': c3, + 'c4': c4, + 'c5': c5, + 'c6': c6} + + param_indexes = {'c0': 0, + 'c1': 1, + 'c2': 2, + 'c3': 3, + 'c4': 4, + 'c5': 5, + 'c6': 6} + + directions = [] + distances = [] + for k, v in params.items(): + directions.append(latent_dirs[param_indexes[k]]) + distances.append(v) + + if w1 is not None and w2 is not None: + w1 = [torch.from_numpy(x).to(device) for x in w1] + w2 = [torch.from_numpy(x).to(device) for x in w2] + + + #w1 = clip_optimized_latent(text1, seed1, iters) + im1 = model.sample(w1) + im1_np = im1.permute(0, 2, 3, 1).cpu().detach().numpy() + im1_np = np.clip(im1_np, 0.0, 1.0).squeeze() + + #w2 = clip_optimized_latent(text2, seed2, iters) + im2 = model.sample(w2) + im2_np = im2.permute(0, 2, 3, 1).cpu().detach().numpy() + im2_np = np.clip(im2_np, 0.0, 1.0).squeeze() + + combined_im = np.concatenate([im1_np, im2_np], axis=1) + input_im = Image.fromarray((combined_im * 255).astype(np.uint8)) + + + mixed_w = mix_w(w1, w2, content, style) + return input_im, display_sample_pytorch(seed1, truncation, directions, distances, scale, int(start_layer), int(end_layer), w=mixed_w, disp=False) + + +# Streamlit app title +st.title("FashionGen Demo - AI assisted fashion design") +"""This application employs the StyleGAN framework, CLIP and GANSpace exploration techniques to synthesize images of garments from textual inputs. With training based on the comprehensive LookBook dataset, it supports an efficient fashion design process by transforming text into visual concepts, showcasing the practical application of Generative Adversarial Networks (GANs) in the realm of creative design.""" + +@st.cache_resource +def load_model(): + device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + # Load the pre-trained CLIP model + clip_model, clip_preprocess = clip.load("ViT-B/32", device=device) + inst = get_instrumented_model(config.model, config.output_class, + config.layer, torch.device('cpu'), use_w=config.use_w) + return clip_model, inst + +# Then, to load your models, call this function: +clip_model, inst = load_model() +model = inst.model + + +path_to_components = get_or_compute(config, inst) +comps = np.load(path_to_components) +lst = comps.files +latent_dirs = [] +latent_stdevs = [] + +load_activations = False + +for item in lst: + if load_activations: + if item == 'act_comp': + for i in range(comps[item].shape[0]): + latent_dirs.append(comps[item][i]) + if item == 'act_stdev': + for i in range(comps[item].shape[0]): + latent_stdevs.append(comps[item][i]) + else: + if item == 'lat_comp': + for i in range(comps[item].shape[0]): + latent_dirs.append(comps[item][i]) + if item == 'lat_stdev': + for i in range(comps[item].shape[0]): + latent_stdevs.append(comps[item][i]) + +## Side bar texts +st.sidebar.title('Tuning Parameters') +st.sidebar.subheader('(CLIP + GANSpace)') + + +# Create UI widgets + +if 'seed1' not in st.session_state and 'seed2' not in st.session_state: + st.session_state['seed1'] = random.randint(1, 1000) + st.session_state['seed2'] = random.randint(1, 1000) +seed1 = st.sidebar.number_input("Seed 1", value= st.session_state['seed1']) +seed2 = st.sidebar.number_input("Seed 2", value= st.session_state['seed2']) +text1 = st.sidebar.text_input("Text Description 1") +text2 = st.sidebar.text_input("Text Description 2") +iters = st.sidebar.number_input("Iterations for CLIP Optimization", value = 25) +submit_button = st.sidebar.button("Submit") +content = st.sidebar.slider("Structural Composition", min_value=0.0, max_value=1.0, value=0.5) +style = st.sidebar.slider("Style", min_value=0.0, max_value=1.0, value=0.5) +truncation = st.sidebar.slider("Dimensional Scaling", min_value=0.0, max_value=1.0, value=0.5) + +slider_min_val = -20 +slider_max_val = 20 +slider_step = 1 + +c0 = st.sidebar.slider("Sleeve Size Scaling", min_value=slider_min_val, max_value=slider_max_val, value=0) +c1 = st.sidebar.slider("Jacket Features", min_value=slider_min_val, max_value=slider_max_val, value=0) +c2 = st.sidebar.slider("Women's Overcoat", min_value=slider_min_val, max_value=slider_max_val, value=0) +c3 = st.sidebar.slider("Coat", min_value=slider_min_val, max_value=slider_max_val, value=0) +c4 = st.sidebar.slider("Graphic Elements", min_value=slider_min_val, max_value=slider_max_val, value=0) +c5 = st.sidebar.slider("Darker Color", min_value=slider_min_val, max_value=slider_max_val, value=0) +c6 = st.sidebar.slider("Modest Neckline", min_value=slider_min_val, max_value=slider_max_val, value=0) +start_layer = st.sidebar.number_input("Start Layer", value=0) +end_layer = st.sidebar.number_input("End Layer", value=14) + + + +if submit_button: # Execute when the submit button is pressed + w1 = clip_optimized_latent(text1, seed1, iters) + st.session_state['w1-np'] = w1 + w2 = clip_optimized_latent(text2, seed2, iters) + st.session_state['w2-np'] = w2 + +try: + input_im, output_im = generate_image(content, style, truncation, c0, c1, c2, c3, c4, c5, c6, start_layer, end_layer,st.session_state['w1-np'],st.session_state['w2-np']) + st.image(input_im, caption="Input Image") + st.image(output_im, caption="Output Image") +except: + pass + + diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..76f9b44149dcc4e4d7a998207e62ddd3301f7502 --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2023 prathmeshdahikar + +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 index 10aab24bb17e1f68f3a0e4ce739aa7b7e8f1c65d..0fad362fde5490610ba5809e8c83974678eb7a66 100644 --- a/README.md +++ b/README.md @@ -1,13 +1,2 @@ ---- -title: FashionGen -emoji: 🦀 -colorFrom: indigo -colorTo: indigo -sdk: streamlit -sdk_version: 1.19.0 -app_file: app.py -pinned: false -license: afl-3.0 ---- - -Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference +# FashionGen +AI assisted fashion design diff --git a/TkTorchWindow.py b/TkTorchWindow.py new file mode 100644 index 0000000000000000000000000000000000000000..fbe1ef1cc35c2590b0a5976254af3f146de4d9b3 --- /dev/null +++ b/TkTorchWindow.py @@ -0,0 +1,208 @@ +# Copyright 2020 Erik Härkönen. All rights reserved. +# This file is licensed to you under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. You may obtain a copy +# of the License at http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software distributed under +# the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS +# OF ANY KIND, either express or implied. See the License for the specific language +# governing permissions and limitations under the License. + +import tkinter as tk +import numpy as np +import time +from contextlib import contextmanager +import pycuda.driver +from pycuda.gl import graphics_map_flags +from glumpy import gloo, gl +from pyopengltk import OpenGLFrame +import torch +from torch.autograd import Variable + +# TkInter widget that can draw torch tensors directly from GPU memory + +@contextmanager +def cuda_activate(img): + """Context manager simplifying use of pycuda.gl.RegisteredImage""" + mapping = img.map() + yield mapping.array(0,0) + mapping.unmap() + +def create_shared_texture(w, h, c=4, + map_flags=graphics_map_flags.WRITE_DISCARD, + dtype=np.uint8): + """Create and return a Texture2D with gloo and pycuda views.""" + tex = np.zeros((h,w,c), dtype).view(gloo.Texture2D) + tex.activate() # force gloo to create on GPU + tex.deactivate() + cuda_buffer = pycuda.gl.RegisteredImage( + int(tex.handle), tex.target, map_flags) + return tex, cuda_buffer + +# Shape batch as square if possible +def get_grid_dims(B): + S = int(B**0.5 + 0.5) + while B % S != 0: + S -= 1 + return (B // S, S) + +def create_gl_texture(tensor_shape): + if len(tensor_shape) != 4: + raise RuntimeError('Please provide a tensor of shape NCHW') + + N, C, H, W = tensor_shape + + cols, rows = get_grid_dims(N) + tex, cuda_buffer = create_shared_texture(W*cols, H*rows, 4) + + return tex, cuda_buffer + +# Create window with OpenGL context +class TorchImageView(OpenGLFrame): + def __init__(self, root = None, show_fps=True, **kwargs): + self.root = root or tk.Tk() + self.width = kwargs.get('width', 512) + self.height = kwargs.get('height', 512) + self.show_fps = show_fps + self.pycuda_initialized = False + self.animate = 0 # disable internal main loop + OpenGLFrame.__init__(self, root, **kwargs) + + # Called by pyopengltk.BaseOpenGLFrame + # when the frame goes onto the screen + def initgl(self): + if not self.pycuda_initialized: + self.setup_gl(self.width, self.height) + self.pycuda_initialized = True + + """Initalize gl states when the frame is created""" + gl.glViewport(0, 0, self.width, self.height) + gl.glClearColor(0.0, 0.0, 0.0, 0.0) + self.dt_history = [1000/60] + self.t0 = time.time() + self.t_last = self.t0 + self.nframes = 0 + + def setup_gl(self, width, height): + # setup pycuda and torch + import pycuda.gl.autoinit + import pycuda.gl + + assert torch.cuda.is_available(), "PyTorch: CUDA is not available" + print('Using GPU {}'.format(torch.cuda.current_device())) + + # Create tensor to be shared between GL and CUDA + # Always overwritten so no sharing is necessary + dummy = torch.cuda.FloatTensor((1)) + dummy.uniform_() + dummy = Variable(dummy) + + # Create a buffer with pycuda and gloo views, using tensor created above + self.tex, self.cuda_buffer = create_gl_texture((1, 3, width, height)) + + # create a shader to program to draw to the screen + vertex = """ + uniform float scale; + attribute vec2 position; + attribute vec2 texcoord; + varying vec2 v_texcoord; + void main() + { + v_texcoord = texcoord; + gl_Position = vec4(scale*position, 0.0, 1.0); + } """ + fragment = """ + uniform sampler2D tex; + varying vec2 v_texcoord; + void main() + { + gl_FragColor = texture2D(tex, v_texcoord); + } """ + # Build the program and corresponding buffers (with 4 vertices) + self.screen = gloo.Program(vertex, fragment, count=4) + + # NDC coordinates: Texcoords: Vertex order, + # (-1, +1) (+1, +1) (0,0) (1,0) triangle strip: + # +-------+ +----+ 1----3 + # | NDC | | | | / | + # | SPACE | | | | / | + # +-------+ +----+ 2----4 + # (-1, -1) (+1, -1) (0,1) (1,1) + + # Upload data to GPU + self.screen['position'] = [(-1,+1), (-1,-1), (+1,+1), (+1,-1)] + self.screen['texcoord'] = [(0,0), (0,1), (1,0), (1,1)] + self.screen['scale'] = 1.0 + self.screen['tex'] = self.tex + + # Don't call directly, use update() instead + def redraw(self): + t_now = time.time() + dt = t_now - self.t_last + self.t_last = t_now + + self.dt_history = ([dt] + self.dt_history)[:50] + dt_mean = sum(self.dt_history) / len(self.dt_history) + + if self.show_fps and self.nframes % 60 == 0: + self.master.title('FPS: {:.0f}'.format(1 / dt_mean)) + + def draw(self, img): + assert len(img.shape) == 4, "Please provide an NCHW image tensor" + assert img.device.type == "cuda", "Please provide a CUDA tensor" + + if img.dtype.is_floating_point: + img = (255*img).byte() + + # Tile images + N, C, H, W = img.shape + + if N > 1: + cols, rows = get_grid_dims(N) + img = img.reshape(cols, rows, C, H, W) + img = img.permute(2, 1, 3, 0, 4) # [C, rows, H, cols, W] + img = img.reshape(1, C, rows*H, cols*W) + + tensor = img.squeeze().permute(1, 2, 0).data # CHW => HWC + if C == 3: + tensor = torch.cat((tensor, tensor[:,:,0:1]),2) # add the alpha channel + tensor[:,:,3] = 1 # set alpha + + tensor = tensor.contiguous() + + tex_h, tex_w, _ = self.tex.shape + tensor_h, tensor_w, _ = tensor.shape + + if (tex_h, tex_w) != (tensor_h, tensor_w): + print(f'Resizing texture to {tensor_w}*{tensor_h}') + self.tex, self.cuda_buffer = create_gl_texture((N, C, H, W)) # original shape + self.screen['tex'] = self.tex + + # copy from torch into buffer + assert self.tex.nbytes == tensor.numel()*tensor.element_size(), "Tensor and texture shape mismatch!" + with cuda_activate(self.cuda_buffer) as ary: + cpy = pycuda.driver.Memcpy2D() + cpy.set_src_device(tensor.data_ptr()) + cpy.set_dst_array(ary) + cpy.width_in_bytes = cpy.src_pitch = cpy.dst_pitch = self.tex.nbytes//tensor_h + cpy.height = tensor_h + cpy(aligned=False) + torch.cuda.synchronize() + + # draw to screen + self.screen.draw(gl.GL_TRIANGLE_STRIP) + + def update(self): + self.update_idletasks() + self.tkMakeCurrent() + self.redraw() + self.tkSwapBuffers() + +# USAGE: +# root = tk.Tk() +# iv = TorchImageView(root, width=512, height=512) +# iv.pack(fill='both', expand=True) +# while True: +# iv.draw(nchw_tensor) +# root.update() +# iv.update() \ No newline at end of file diff --git a/bpe_simple_vocab_16e6.txt.gz b/bpe_simple_vocab_16e6.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..36a15856e00a06a9fbed8cdd34d2393fea4a3113 --- /dev/null +++ b/bpe_simple_vocab_16e6.txt.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:924691ac288e54409236115652ad4aa250f48203de50a9e4722a6ecd48d6804a +size 1356917 diff --git a/cache/components/stylegan2-lookbook_style_ipca_c80_n300000_w.npz b/cache/components/stylegan2-lookbook_style_ipca_c80_n300000_w.npz new file mode 100644 index 0000000000000000000000000000000000000000..0ab45d78cdd4e35a00944b6f87ac2b89b85de355 --- /dev/null +++ b/cache/components/stylegan2-lookbook_style_ipca_c80_n300000_w.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:80cde5f3476909d69649ebcb1f9872d0fd95cb1632770db1b7fb962608f905b8 +size 312351 diff --git a/clip.py b/clip.py new file mode 100644 index 0000000000000000000000000000000000000000..277df5ef71bc4bffca13dc462ccdd3151371f6ce --- /dev/null +++ b/clip.py @@ -0,0 +1,237 @@ +import hashlib +import os +import urllib +import warnings +from typing import Any, Union, List +from pkg_resources import packaging + +import torch +from PIL import Image +from torchvision.transforms import Compose, Resize, CenterCrop, ToTensor, Normalize +from tqdm import tqdm + +from model_clip import build_model +from simple_tokenizer import SimpleTokenizer as _Tokenizer + +try: + from torchvision.transforms import InterpolationMode + BICUBIC = InterpolationMode.BICUBIC +except ImportError: + BICUBIC = Image.BICUBIC + + +if packaging.version.parse(torch.__version__) < packaging.version.parse("1.7.1"): + warnings.warn("PyTorch version 1.7.1 or higher is recommended") + + +__all__ = ["available_models", "load", "tokenize"] +_tokenizer = _Tokenizer() + +_MODELS = { + "RN50": "https://openaipublic.azureedge.net/clip/models/afeb0e10f9e5a86da6080e35cf09123aca3b358a0c3e3b6c78a7b63bc04b6762/RN50.pt", + "RN101": "https://openaipublic.azureedge.net/clip/models/8fa8567bab74a42d41c5915025a8e4538c3bdbe8804a470a72f30b0d94fab599/RN101.pt", + "RN50x4": "https://openaipublic.azureedge.net/clip/models/7e526bd135e493cef0776de27d5f42653e6b4c8bf9e0f653bb11773263205fdd/RN50x4.pt", + "RN50x16": "https://openaipublic.azureedge.net/clip/models/52378b407f34354e150460fe41077663dd5b39c54cd0bfd2b27167a4a06ec9aa/RN50x16.pt", + "RN50x64": "https://openaipublic.azureedge.net/clip/models/be1cfb55d75a9666199fb2206c106743da0f6468c9d327f3e0d0a543a9919d9c/RN50x64.pt", + "ViT-B/32": "https://openaipublic.azureedge.net/clip/models/40d365715913c9da98579312b702a82c18be219cc2a73407c4526f58eba950af/ViT-B-32.pt", + "ViT-B/16": "https://openaipublic.azureedge.net/clip/models/5806e77cd80f8b59890b7e101eabd078d9fb84e6937f9e85e4ecb61988df416f/ViT-B-16.pt", + "ViT-L/14": "https://openaipublic.azureedge.net/clip/models/b8cca3fd41ae0c99ba7e8951adf17d267cdb84cd88be6f7c2e0eca1737a03836/ViT-L-14.pt", + "ViT-L/14@336px": "https://openaipublic.azureedge.net/clip/models/3035c92b350959924f9f00213499208652fc7ea050643e8b385c2dac08641f02/ViT-L-14-336px.pt", +} + + +def _download(url: str, root: str): + os.makedirs(root, exist_ok=True) + filename = os.path.basename(url) + + expected_sha256 = url.split("/")[-2] + download_target = os.path.join(root, filename) + + if os.path.exists(download_target) and not os.path.isfile(download_target): + raise RuntimeError(f"{download_target} exists and is not a regular file") + + if os.path.isfile(download_target): + if hashlib.sha256(open(download_target, "rb").read()).hexdigest() == expected_sha256: + return download_target + else: + warnings.warn(f"{download_target} exists, but the SHA256 checksum does not match; re-downloading the file") + + with urllib.request.urlopen(url) as source, open(download_target, "wb") as output: + with tqdm(total=int(source.info().get("Content-Length")), ncols=80, unit='iB', unit_scale=True, unit_divisor=1024) as loop: + while True: + buffer = source.read(8192) + if not buffer: + break + + output.write(buffer) + loop.update(len(buffer)) + + if hashlib.sha256(open(download_target, "rb").read()).hexdigest() != expected_sha256: + raise RuntimeError("Model has been downloaded but the SHA256 checksum does not not match") + + return download_target + + +def _convert_image_to_rgb(image): + return image.convert("RGB") + + +def _transform(n_px): + return Compose([ + Resize(n_px, interpolation=BICUBIC), + CenterCrop(n_px), + _convert_image_to_rgb, + ToTensor(), + Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711)), + ]) + + +def available_models() -> List[str]: + """Returns the names of available CLIP models""" + return list(_MODELS.keys()) + + +def load(name: str, device: Union[str, torch.device] = "cuda" if torch.cuda.is_available() else "cpu", jit: bool = False, download_root: str = None): + """Load a CLIP model + + Parameters + ---------- + name : str + A model name listed by `clip.available_models()`, or the path to a model checkpoint containing the state_dict + + device : Union[str, torch.device] + The device to put the loaded model + + jit : bool + Whether to load the optimized JIT model or more hackable non-JIT model (default). + + download_root: str + path to download the model files; by default, it uses "~/.cache/clip" + + Returns + ------- + model : torch.nn.Module + The CLIP model + + preprocess : Callable[[PIL.Image], torch.Tensor] + A torchvision transform that converts a PIL image into a tensor that the returned model can take as its input + """ + if name in _MODELS: + model_path = _download(_MODELS[name], download_root or os.path.expanduser("~/.cache/clip")) + elif os.path.isfile(name): + model_path = name + else: + raise RuntimeError(f"Model {name} not found; available models = {available_models()}") + + with open(model_path, 'rb') as opened_file: + try: + # loading JIT archive + model = torch.jit.load(opened_file, map_location=device if jit else "cpu").eval() + state_dict = None + except RuntimeError: + # loading saved state dict + if jit: + warnings.warn(f"File {model_path} is not a JIT archive. Loading as a state dict instead") + jit = False + state_dict = torch.load(opened_file, map_location="cpu") + + if not jit: + model = build_model(state_dict or model.state_dict()).to(device) + if str(device) == "cpu": + model.float() + return model, _transform(model.visual.input_resolution) + + # patch the device names + device_holder = torch.jit.trace(lambda: torch.ones([]).to(torch.device(device)), example_inputs=[]) + device_node = [n for n in device_holder.graph.findAllNodes("prim::Constant") if "Device" in repr(n)][-1] + + def patch_device(module): + try: + graphs = [module.graph] if hasattr(module, "graph") else [] + except RuntimeError: + graphs = [] + + if hasattr(module, "forward1"): + graphs.append(module.forward1.graph) + + for graph in graphs: + for node in graph.findAllNodes("prim::Constant"): + if "value" in node.attributeNames() and str(node["value"]).startswith("cuda"): + node.copyAttributes(device_node) + + model.apply(patch_device) + patch_device(model.encode_image) + patch_device(model.encode_text) + + # patch dtype to float32 on CPU + if str(device) == "cpu": + float_holder = torch.jit.trace(lambda: torch.ones([]).float(), example_inputs=[]) + float_input = list(float_holder.graph.findNode("aten::to").inputs())[1] + float_node = float_input.node() + + def patch_float(module): + try: + graphs = [module.graph] if hasattr(module, "graph") else [] + except RuntimeError: + graphs = [] + + if hasattr(module, "forward1"): + graphs.append(module.forward1.graph) + + for graph in graphs: + for node in graph.findAllNodes("aten::to"): + inputs = list(node.inputs()) + for i in [1, 2]: # dtype can be the second or third argument to aten::to() + if inputs[i].node()["value"] == 5: + inputs[i].node().copyAttributes(float_node) + + model.apply(patch_float) + patch_float(model.encode_image) + patch_float(model.encode_text) + + model.float() + + return model, _transform(model.input_resolution.item()) + + +def tokenize(texts: Union[str, List[str]], context_length: int = 77, truncate: bool = False) -> Union[torch.IntTensor, torch.LongTensor]: + """ + Returns the tokenized representation of given input string(s) + + Parameters + ---------- + texts : Union[str, List[str]] + An input string or a list of input strings to tokenize + + context_length : int + The context length to use; all CLIP models use 77 as the context length + + truncate: bool + Whether to truncate the text in case its encoding is longer than the context length + + Returns + ------- + A two-dimensional tensor containing the resulting tokens, shape = [number of input strings, context_length]. + We return LongTensor when torch version is <1.8.0, since older index_select requires indices to be long. + """ + if isinstance(texts, str): + texts = [texts] + + sot_token = _tokenizer.encoder["<|startoftext|>"] + eot_token = _tokenizer.encoder["<|endoftext|>"] + all_tokens = [[sot_token] + _tokenizer.encode(text) + [eot_token] for text in texts] + if packaging.version.parse(torch.__version__) < packaging.version.parse("1.8.0"): + result = torch.zeros(len(all_tokens), context_length, dtype=torch.long) + else: + result = torch.zeros(len(all_tokens), context_length, dtype=torch.int) + + for i, tokens in enumerate(all_tokens): + if len(tokens) > context_length: + if truncate: + tokens = tokens[:context_length] + tokens[-1] = eot_token + else: + raise RuntimeError(f"Input {texts[i]} is too long for context length {context_length}") + result[i, :len(tokens)] = torch.tensor(tokens) + + return result diff --git a/config.py b/config.py new file mode 100644 index 0000000000000000000000000000000000000000..5af238a0a4382504bd2af894d30331e1be33079a --- /dev/null +++ b/config.py @@ -0,0 +1,72 @@ +# Copyright 2020 Erik Härkönen. All rights reserved. +# This file is licensed to you under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. You may obtain a copy +# of the License at http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software distributed under +# the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS +# OF ANY KIND, either express or implied. See the License for the specific language +# governing permissions and limitations under the License. + +import sys +import argparse +import json +from copy import deepcopy + +class Config: + def __init__(self, **kwargs): + self.from_args([]) # set all defaults + self.default_args = deepcopy(self.__dict__) + self.from_dict(kwargs) # override + + def __str__(self): + custom = {} + default = {} + + # Find non-default arguments + for k, v in self.__dict__.items(): + if k == 'default_args': + continue + + in_default = k in self.default_args + same_value = self.default_args.get(k) == v + + if in_default and same_value: + default[k] = v + else: + custom[k] = v + + config = { + 'custom': custom, + 'default': default + } + + return json.dumps(config, indent=4) + + def __repr__(self): + return self.__str__() + + def from_dict(self, dictionary): + for k, v in dictionary.items(): + setattr(self, k, v) + return self + + def from_args(self, args=sys.argv[1:]): + parser = argparse.ArgumentParser(description='GAN component analysis config') + parser.add_argument('--model', dest='model', type=str, default='StyleGAN', help='The network to analyze') # StyleGAN, DCGAN, ProGAN, BigGAN-XYZ + parser.add_argument('--layer', dest='layer', type=str, default='g_mapping', help='The layer to analyze') + parser.add_argument('--class', dest='output_class', type=str, default=None, help='Output class to generate (BigGAN: Imagenet, ProGAN: LSUN)') + parser.add_argument('--est', dest='estimator', type=str, default='ipca', help='The algorithm to use [pca, fbpca, cupca, spca, ica]') + parser.add_argument('--sparsity', type=float, default=1.0, help='Sparsity parameter of SPCA') + parser.add_argument('--video', dest='make_video', action='store_true', help='Generate output videos (MP4s)') + parser.add_argument('--batch', dest='batch_mode', action='store_true', help="Don't open windows, instead save results to file") + parser.add_argument('-b', dest='batch_size', type=int, default=None, help='Minibatch size, leave empty for automatic detection') + parser.add_argument('-c', dest='components', type=int, default=80, help='Number of components to keep') + parser.add_argument('-n', type=int, default=300_000, help='Number of examples to use in decomposition') + parser.add_argument('--use_w', action='store_true', help='Use W latent space (StyleGAN(2))') + parser.add_argument('--sigma', type=float, default=2.0, help='Number of stdevs to walk in visualize.py') + parser.add_argument('--inputs', type=str, default=None, help='Path to directory with named components') + parser.add_argument('--seed', type=int, default=None, help='Seed used in decomposition') + args = parser.parse_args(args) + + return self.from_dict(args.__dict__) \ No newline at end of file diff --git a/decomposition.py b/decomposition.py new file mode 100644 index 0000000000000000000000000000000000000000..4819e3324707f15c33fba6f35ab6abdc66dea919 --- /dev/null +++ b/decomposition.py @@ -0,0 +1,402 @@ +# Copyright 2020 Erik Härkönen. All rights reserved. +# This file is licensed to you under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. You may obtain a copy +# of the License at http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software distributed under +# the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS +# OF ANY KIND, either express or implied. See the License for the specific language +# governing permissions and limitations under the License. + +# Patch for broken CTRL+C handler +# https://github.com/ContinuumIO/anaconda-issues/issues/905 +import os +os.environ['FOR_DISABLE_CONSOLE_CTRL_HANDLER'] = '1' + +import numpy as np +import os +from pathlib import Path +import re +import sys +import datetime +import argparse +import torch +import json +from types import SimpleNamespace +import scipy +from scipy.cluster.vq import kmeans +from tqdm import trange +from netdissect.nethook import InstrumentedModel +from config import Config +from estimators import get_estimator +from models import get_instrumented_model + +SEED_SAMPLING = 1 +SEED_RANDOM_DIRS = 2 +SEED_LINREG = 3 +SEED_VISUALIZATION = 5 + +B = 20 +n_clusters = 500 + +def get_random_dirs(components, dimensions): + gen = np.random.RandomState(seed=SEED_RANDOM_DIRS) + dirs = gen.normal(size=(components, dimensions)) + dirs /= np.sqrt(np.sum(dirs**2, axis=1, keepdims=True)) + return dirs.astype(np.float32) + +# Compute maximum batch size for given VRAM and network +def get_max_batch_size(inst, device, layer_name=None): + inst.remove_edits() + + # Reset statistics + torch.cuda.reset_max_memory_cached(device) + torch.cuda.reset_max_memory_allocated(device) + total_mem = torch.cuda.get_device_properties(device).total_memory + + B_max = 20 + + # Measure actual usage + for i in range(2, B_max, 2): + z = inst.model.sample_latent(n_samples=i) + if layer_name: + inst.model.partial_forward(z, layer_name) + else: + inst.model.forward(z) + + maxmem = torch.cuda.max_memory_allocated(device) + del z + + if maxmem > 0.5*total_mem: + print('Batch size {:d}: memory usage {:.0f}MB'.format(i, maxmem / 1e6)) + return i + + return B_max + +# Solve for directions in latent space that match PCs in activaiton space +def linreg_lstsq(comp_np, mean_np, stdev_np, inst, config): + print('Performing least squares regression', flush=True) + + torch.manual_seed(SEED_LINREG) + np.random.seed(SEED_LINREG) + + comp = torch.from_numpy(comp_np).float().to(inst.model.device) + mean = torch.from_numpy(mean_np).float().to(inst.model.device) + stdev = torch.from_numpy(stdev_np).float().to(inst.model.device) + + n_samp = max(10_000, config.n) // B * B # make divisible + n_comp = comp.shape[0] + latent_dims = inst.model.get_latent_dims() + + # We're looking for M s.t. M*P*G'(Z) = Z => M*A = Z + # Z = batch of latent vectors (n_samples x latent_dims) + # G'(Z) = batch of activations at intermediate layer + # A = P*G'(Z) = projected activations (n_samples x pca_coords) + # M = linear mapping (pca_coords x latent_dims) + + # Minimization min_M ||MA - Z||_l2 rewritten as min_M.T ||A.T*M.T - Z.T||_l2 + # to match format expected by pytorch.lstsq + + # TODO: regression on pixel-space outputs? (using nonlinear optimizer) + # min_M lpips(G_full(MA), G_full(Z)) + + # Tensors to fill with data + # Dimensions other way around, so these are actually the transposes + A = np.zeros((n_samp, n_comp), dtype=np.float32) + Z = np.zeros((n_samp, latent_dims), dtype=np.float32) + + # Project tensor X onto PCs, return coordinates + def project(X, comp): + N = X.shape[0] + K = comp.shape[0] + coords = torch.bmm(comp.expand([N]+[-1]*comp.ndim), X.view(N, -1, 1)) + return coords.reshape(N, K) + + for i in trange(n_samp // B, desc='Collecting samples', ascii=True): + z = inst.model.sample_latent(B) + inst.model.partial_forward(z, config.layer) + act = inst.retained_features()[config.layer].reshape(B, -1) + + # Project onto basis + act = act - mean + coords = project(act, comp) + coords_scaled = coords / stdev + + A[i*B:(i+1)*B] = coords_scaled.detach().cpu().numpy() + Z[i*B:(i+1)*B] = z.detach().cpu().numpy().reshape(B, -1) + + # Solve least squares fit + + # gelsd = divide-and-conquer SVD; good default + # gelsy = complete orthogonal factorization; sometimes faster + # gelss = SVD; slow but less memory hungry + M_t = scipy.linalg.lstsq(A, Z, lapack_driver='gelsd')[0] # torch.lstsq(Z, A)[0][:n_comp, :] + + # Solution given by rows of M_t + Z_comp = M_t[:n_comp, :] + Z_mean = np.mean(Z, axis=0, keepdims=True) + + return Z_comp, Z_mean + +def regression(comp, mean, stdev, inst, config): + # Sanity check: verify orthonormality + M = np.dot(comp, comp.T) + if not np.allclose(M, np.identity(M.shape[0])): + det = np.linalg.det(M) + print(f'WARNING: Computed basis is not orthonormal (determinant={det})') + + return linreg_lstsq(comp, mean, stdev, inst, config) + +def compute(config, dump_name, instrumented_model): + global B + + timestamp = lambda : datetime.datetime.now().strftime("%d.%m %H:%M") + print(f'[{timestamp()}] Computing', dump_name.name) + + # Ensure reproducibility + torch.manual_seed(0) # also sets cuda seeds + np.random.seed(0) + + # Speed up backend + torch.backends.cudnn.benchmark = True + + has_gpu = torch.cuda.is_available() + device = torch.device('cuda' if has_gpu else 'cpu') + layer_key = config.layer + + if instrumented_model is None: + inst = get_instrumented_model(config.model, config.output_class, layer_key, device) + model = inst.model + else: + print('Reusing InstrumentedModel instance') + inst = instrumented_model + model = inst.model + inst.remove_edits() + model.set_output_class(config.output_class) + + # Regress back to w space + if config.use_w: + print('Using W latent space') + model.use_w() + + inst.retain_layer(layer_key) + model.partial_forward(model.sample_latent(1), layer_key) + sample_shape = inst.retained_features()[layer_key].shape + sample_dims = np.prod(sample_shape) + print('Feature shape:', sample_shape) + + input_shape = inst.model.get_latent_shape() + input_dims = inst.model.get_latent_dims() + + config.components = min(config.components, sample_dims) + transformer = get_estimator(config.estimator, config.components, config.sparsity) + + X = None + X_global_mean = None + + # Figure out batch size if not provided + B = config.batch_size or get_max_batch_size(inst, device, layer_key) + + # Divisible by B (ignored in output name) + N = config.n // B * B + + # Compute maximum batch size based on RAM + pagefile budget + target_bytes = 20 * 1_000_000_000 # GB + feat_size_bytes = sample_dims * np.dtype('float64').itemsize + N_limit_RAM = np.floor_divide(target_bytes, feat_size_bytes) + if not transformer.batch_support and N > N_limit_RAM: + print('WARNING: estimator does not support batching, ' \ + 'given config will use {:.1f} GB memory.'.format(feat_size_bytes / 1_000_000_000 * N)) + + # 32-bit LAPACK gets very unhappy about huge matrices (in linalg.svd) + if config.estimator == 'ica': + lapack_max_N = np.floor_divide(np.iinfo(np.int32).max // 4, sample_dims) # 4x extra buffer + if N > lapack_max_N: + raise RuntimeError(f'Matrices too large for ICA, please use N <= {lapack_max_N}') + + print('B={}, N={}, dims={}, N/dims={:.1f}'.format(B, N, sample_dims, N/sample_dims), flush=True) + + # Must not depend on chosen batch size (reproducibility) + NB = max(B, max(2_000, 3*config.components)) # ipca: as large as possible! + + samples = None + if not transformer.batch_support: + samples = np.zeros((N + NB, sample_dims), dtype=np.float32) + + torch.manual_seed(config.seed or SEED_SAMPLING) + np.random.seed(config.seed or SEED_SAMPLING) + + # Use exactly the same latents regardless of batch size + # Store in main memory, since N might be huge (1M+) + # Run in batches, since sample_latent() might perform Z -> W mapping + n_lat = ((N + NB - 1) // B + 1) * B + latents = np.zeros((n_lat, *input_shape[1:]), dtype=np.float32) + with torch.no_grad(): + for i in trange(n_lat // B, desc='Sampling latents'): + latents[i*B:(i+1)*B] = model.sample_latent(n_samples=B).cpu().numpy() + + # Decomposition on non-Gaussian latent space + samples_are_latents = layer_key in ['g_mapping', 'style'] and inst.model.latent_space_name() == 'W' + + canceled = False + try: + X = np.ones((NB, sample_dims), dtype=np.float32) + action = 'Fitting' if transformer.batch_support else 'Collecting' + for gi in trange(0, N, NB, desc=f'{action} batches (NB={NB})', ascii=True): + for mb in range(0, NB, B): + z = torch.from_numpy(latents[gi+mb:gi+mb+B]).to(device) + + if samples_are_latents: + # Decomposition on latents directly (e.g. StyleGAN W) + batch = z.reshape((B, -1)) + else: + # Decomposition on intermediate layer + with torch.no_grad(): + model.partial_forward(z, layer_key) + + # Permuted to place PCA dimensions last + batch = inst.retained_features()[layer_key].reshape((B, -1)) + + space_left = min(B, NB - mb) + X[mb:mb+space_left] = batch.cpu().numpy()[:space_left] + + if transformer.batch_support: + if not transformer.fit_partial(X.reshape(-1, sample_dims)): + break + else: + samples[gi:gi+NB, :] = X.copy() + except KeyboardInterrupt: + if not transformer.batch_support: + sys.exit(1) # no progress yet + + dump_name = dump_name.parent / dump_name.name.replace(f'n{N}', f'n{gi}') + print(f'Saving current state to "{dump_name.name}" before exiting') + canceled = True + + if not transformer.batch_support: + X = samples # Use all samples + X_global_mean = X.mean(axis=0, keepdims=True, dtype=np.float32) # TODO: activations surely multi-modal...! + X -= X_global_mean + + print(f'[{timestamp()}] Fitting whole batch') + t_start_fit = datetime.datetime.now() + + transformer.fit(X) + + print(f'[{timestamp()}] Done in {datetime.datetime.now() - t_start_fit}') + assert np.all(transformer.transformer.mean_ < 1e-3), 'Mean of normalized data should be zero' + else: + X_global_mean = transformer.transformer.mean_.reshape((1, sample_dims)) + X = X.reshape(-1, sample_dims) + X -= X_global_mean + + X_comp, X_stdev, X_var_ratio = transformer.get_components() + + assert X_comp.shape[1] == sample_dims \ + and X_comp.shape[0] == config.components \ + and X_global_mean.shape[1] == sample_dims \ + and X_stdev.shape[0] == config.components, 'Invalid shape' + + # 'Activations' are really latents in a secondary latent space + if samples_are_latents: + Z_comp = X_comp + Z_global_mean = X_global_mean + else: + Z_comp, Z_global_mean = regression(X_comp, X_global_mean, X_stdev, inst, config) + + # Normalize + Z_comp /= np.linalg.norm(Z_comp, axis=-1, keepdims=True) + + # Random projections + # We expect these to explain much less of the variance + random_dirs = get_random_dirs(config.components, np.prod(sample_shape)) + n_rand_samples = min(5000, X.shape[0]) + X_view = X[:n_rand_samples, :].T + assert np.shares_memory(X_view, X), "Error: slice produced copy" + X_stdev_random = np.dot(random_dirs, X_view).std(axis=1) + + # Inflate back to proper shapes (for easier broadcasting) + X_comp = X_comp.reshape(-1, *sample_shape) + X_global_mean = X_global_mean.reshape(sample_shape) + Z_comp = Z_comp.reshape(-1, *input_shape) + Z_global_mean = Z_global_mean.reshape(input_shape) + + # Compute stdev in latent space if non-Gaussian + lat_stdev = np.ones_like(X_stdev) + if config.use_w: + samples = model.sample_latent(5000).reshape(5000, input_dims).detach().cpu().numpy() + coords = np.dot(Z_comp.reshape(-1, input_dims), samples.T) + lat_stdev = coords.std(axis=1) + + os.makedirs(dump_name.parent, exist_ok=True) + np.savez_compressed(dump_name, **{ + 'act_comp': X_comp.astype(np.float32), + 'act_mean': X_global_mean.astype(np.float32), + 'act_stdev': X_stdev.astype(np.float32), + 'lat_comp': Z_comp.astype(np.float32), + 'lat_mean': Z_global_mean.astype(np.float32), + 'lat_stdev': lat_stdev.astype(np.float32), + 'var_ratio': X_var_ratio.astype(np.float32), + 'random_stdevs': X_stdev_random.astype(np.float32), + }) + + if canceled: + sys.exit(1) + + # Don't shutdown if passed as param + if instrumented_model is None: + inst.close() + del inst + del model + + del X + del X_comp + del random_dirs + del batch + del samples + del latents + torch.cuda.empty_cache() + +# Return cached results or commpute if needed +# Pass existing InstrumentedModel instance to reuse it +def get_or_compute(config, model=None, submit_config=None, force_recompute=False): + if submit_config is None: + wrkdir = str(Path(__file__).parent.resolve()) + submit_config = SimpleNamespace(run_dir_root = wrkdir, run_dir = wrkdir) + + # Called directly by run.py + return _compute(submit_config, config, model, force_recompute) + +def _compute(submit_config, config, model=None, force_recompute=False): + basedir = Path(submit_config.run_dir) + outdir = basedir / 'out' + + if config.n is None: + raise RuntimeError('Must specify number of samples with -n=XXX') + + if model and not isinstance(model, InstrumentedModel): + raise RuntimeError('Passed model has to be wrapped in "InstrumentedModel"') + + if config.use_w and not 'StyleGAN' in config.model: + raise RuntimeError(f'Cannot change latent space of non-StyleGAN model {config.model}') + + transformer = get_estimator(config.estimator, config.components, config.sparsity) + dump_name = "{}-{}_{}_{}_n{}{}{}.npz".format( + config.model.lower(), + config.output_class.replace(' ', '_'), + config.layer.lower(), + transformer.get_param_str(), + config.n, + '_w' if config.use_w else '', + f'_seed{config.seed}' if config.seed else '' + ) + + dump_path = basedir / 'cache' / 'components' / dump_name + + if not dump_path.is_file() or force_recompute: + print('Not cached') + t_start = datetime.datetime.now() + compute(config, dump_path, model) + print('Total time:', datetime.datetime.now() - t_start) + + return dump_path \ No newline at end of file diff --git a/deps/windows/PyOpenGL-3.1.4-cp37-cp37m-win_amd64.whl b/deps/windows/PyOpenGL-3.1.4-cp37-cp37m-win_amd64.whl new file mode 100644 index 0000000000000000000000000000000000000000..39c5357942501bcf3c4b66be368a4f74d41426a2 --- /dev/null +++ b/deps/windows/PyOpenGL-3.1.4-cp37-cp37m-win_amd64.whl @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e6ff6658d48c4c941bc230e9d46c8b6fe593de1c4c523f7b0b678a6a4f920a1e +size 2849264 diff --git a/deps/windows/glumpy-1.1.0-cp37-cp37m-win_amd64.whl b/deps/windows/glumpy-1.1.0-cp37-cp37m-win_amd64.whl new file mode 100644 index 0000000000000000000000000000000000000000..11a951ece02c957473c8a3adfd873b19e0db7d2f --- /dev/null +++ b/deps/windows/glumpy-1.1.0-cp37-cp37m-win_amd64.whl @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6e8984115f12b78ea29196d5d34bdddbf080674c3b6c6673b3daa037b61812cb +size 1061208 diff --git a/deps/windows/pycuda-2019.1.2+cuda101-cp37-cp37m-win_amd64.whl b/deps/windows/pycuda-2019.1.2+cuda101-cp37-cp37m-win_amd64.whl new file mode 100644 index 0000000000000000000000000000000000000000..2ff46c4daf65d7a719552423639fab83a2932b52 Binary files /dev/null and b/deps/windows/pycuda-2019.1.2+cuda101-cp37-cp37m-win_amd64.whl differ diff --git a/deps/windows/triangle-20190115.3-cp37-cp37m-win_amd64.whl b/deps/windows/triangle-20190115.3-cp37-cp37m-win_amd64.whl new file mode 100644 index 0000000000000000000000000000000000000000..abbc15b370b13687815e88c80ff336f5fb7d0083 --- /dev/null +++ b/deps/windows/triangle-20190115.3-cp37-cp37m-win_amd64.whl @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d86a42322673b599a930384b2272b3c3bc666e1c75c994c12f4dd7065e5d44bc +size 1431810 diff --git a/environment.yml b/environment.yml new file mode 100644 index 0000000000000000000000000000000000000000..4e0d3ac4d0de9bbac447ba439e890a37ca61e2f7 --- /dev/null +++ b/environment.yml @@ -0,0 +1,25 @@ +name: ganspace +channels: + - defaults + - conda-forge + - pytorch +dependencies: + - python=3.7 + - pytorch::pytorch=1.3 + - pytorch::torchvision + - cudatoolkit=10.1 + - pillow=6.2 + - ffmpeg + - tqdm + - scipy + - scikit-learn + - scikit-image + - boto3 + - requests + - nltk + - pip + - pip: + - fbpca + - pyopengltk + +# conda env update -f environment.yml --prune diff --git a/estimators.py b/estimators.py new file mode 100644 index 0000000000000000000000000000000000000000..470858c8edc85a64f035fe12ceaf37182ecd497f --- /dev/null +++ b/estimators.py @@ -0,0 +1,218 @@ +# Copyright 2020 Erik Härkönen. All rights reserved. +# This file is licensed to you under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. You may obtain a copy +# of the License at http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software distributed under +# the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS +# OF ANY KIND, either express or implied. See the License for the specific language +# governing permissions and limitations under the License. + +from sklearn.decomposition import FastICA, PCA, IncrementalPCA, MiniBatchSparsePCA, SparsePCA, KernelPCA +import fbpca +import numpy as np +import itertools +from types import SimpleNamespace + +# ICA +class ICAEstimator(): + def __init__(self, n_components): + self.n_components = n_components + self.maxiter = 10000 + self.whiten = True # ICA: whitening is essential, should not be skipped + self.transformer = FastICA(n_components, random_state=0, whiten=self.whiten, max_iter=self.maxiter) + self.batch_support = False + self.stdev = np.zeros((n_components,)) + self.total_var = 0.0 + + def get_param_str(self): + return "ica_c{}{}".format(self.n_components, '_w' if self.whiten else '') + + def fit(self, X): + self.transformer.fit(X) + if self.transformer.n_iter_ >= self.maxiter: + raise RuntimeError(f'FastICA did not converge (N={X.shape[0]}, it={self.maxiter})') + + # Normalize components + self.transformer.components_ /= np.sqrt(np.sum(self.transformer.components_**2, axis=-1, keepdims=True)) + + # Save variance for later + self.total_var = X.var(axis=0).sum() + + # Compute projected standard deviations + self.stdev = np.dot(self.transformer.components_, X.T).std(axis=1) + + # Sort components based on explained variance + idx = np.argsort(self.stdev)[::-1] + self.stdev = self.stdev[idx] + self.transformer.components_[:] = self.transformer.components_[idx] + + def get_components(self): + var_ratio = self.stdev**2 / self.total_var + return self.transformer.components_, self.stdev, var_ratio # ICA outputs are not normalized + +# Incremental PCA +class IPCAEstimator(): + def __init__(self, n_components): + self.n_components = n_components + self.whiten = False + self.transformer = IncrementalPCA(n_components, whiten=self.whiten, batch_size=max(100, 2*n_components)) + self.batch_support = True + + def get_param_str(self): + return "ipca_c{}{}".format(self.n_components, '_w' if self.whiten else '') + + def fit(self, X): + self.transformer.fit(X) + + def fit_partial(self, X): + try: + self.transformer.partial_fit(X) + self.transformer.n_samples_seen_ = \ + self.transformer.n_samples_seen_.astype(np.int64) # avoid overflow + return True + except ValueError as e: + print(f'\nIPCA error:', e) + return False + + def get_components(self): + stdev = np.sqrt(self.transformer.explained_variance_) # already sorted + var_ratio = self.transformer.explained_variance_ratio_ + return self.transformer.components_, stdev, var_ratio # PCA outputs are normalized + +# Standard PCA +class PCAEstimator(): + def __init__(self, n_components): + self.n_components = n_components + self.solver = 'full' + self.transformer = PCA(n_components, svd_solver=self.solver) + self.batch_support = False + + def get_param_str(self): + return f"pca-{self.solver}_c{self.n_components}" + + def fit(self, X): + self.transformer.fit(X) + + # Save variance for later + self.total_var = X.var(axis=0).sum() + + # Compute projected standard deviations + self.stdev = np.dot(self.transformer.components_, X.T).std(axis=1) + + # Sort components based on explained variance + idx = np.argsort(self.stdev)[::-1] + self.stdev = self.stdev[idx] + self.transformer.components_[:] = self.transformer.components_[idx] + + # Check orthogonality + dotps = [np.dot(*self.transformer.components_[[i, j]]) + for (i, j) in itertools.combinations(range(self.n_components), 2)] + if not np.allclose(dotps, 0, atol=1e-4): + print('IPCA components not orghogonal, max dot', np.abs(dotps).max()) + + self.transformer.mean_ = X.mean(axis=0, keepdims=True) + + def get_components(self): + var_ratio = self.stdev**2 / self.total_var + return self.transformer.components_, self.stdev, var_ratio + +# Facebook's PCA +# Good default choice: very fast and accurate. +# Very high sample counts won't fit into RAM, +# in which case IncrementalPCA must be used. +class FacebookPCAEstimator(): + def __init__(self, n_components): + self.n_components = n_components + self.transformer = SimpleNamespace() + self.batch_support = False + self.n_iter = 2 + self.l = 2*self.n_components + + def get_param_str(self): + return "fbpca_c{}_it{}_l{}".format(self.n_components, self.n_iter, self.l) + + def fit(self, X): + U, s, Va = fbpca.pca(X, k=self.n_components, n_iter=self.n_iter, raw=True, l=self.l) + self.transformer.components_ = Va + + # Save variance for later + self.total_var = X.var(axis=0).sum() + + # Compute projected standard deviations + self.stdev = np.dot(self.transformer.components_, X.T).std(axis=1) + + # Sort components based on explained variance + idx = np.argsort(self.stdev)[::-1] + self.stdev = self.stdev[idx] + self.transformer.components_[:] = self.transformer.components_[idx] + + # Check orthogonality + dotps = [np.dot(*self.transformer.components_[[i, j]]) + for (i, j) in itertools.combinations(range(self.n_components), 2)] + if not np.allclose(dotps, 0, atol=1e-4): + print('FBPCA components not orghogonal, max dot', np.abs(dotps).max()) + + self.transformer.mean_ = X.mean(axis=0, keepdims=True) + + def get_components(self): + var_ratio = self.stdev**2 / self.total_var + return self.transformer.components_, self.stdev, var_ratio + +# Sparse PCA +# The algorithm is online along the features direction, not the samples direction +# => no partial_fit +class SPCAEstimator(): + def __init__(self, n_components, alpha=10.0): + self.n_components = n_components + self.whiten = False + self.alpha = alpha # higher alpha => sparser components + #self.transformer = MiniBatchSparsePCA(n_components, alpha=alpha, n_iter=100, + # batch_size=max(20, n_components//5), random_state=0, normalize_components=True) + self.transformer = SparsePCA(n_components, alpha=alpha, ridge_alpha=0.01, + max_iter=100, random_state=0, n_jobs=-1, normalize_components=True) # TODO: warm start using PCA result? + self.batch_support = False # maybe through memmap and HDD-stored tensor + self.stdev = np.zeros((n_components,)) + self.total_var = 0.0 + + def get_param_str(self): + return "spca_c{}_a{}{}".format(self.n_components, self.alpha, '_w' if self.whiten else '') + + def fit(self, X): + self.transformer.fit(X) + + # Save variance for later + self.total_var = X.var(axis=0).sum() + + # Compute projected standard deviations + # NB: cannot simply project with dot product! + self.stdev = self.transformer.transform(X).std(axis=0) # X = (n_samples, n_features) + + # Sort components based on explained variance + idx = np.argsort(self.stdev)[::-1] + self.stdev = self.stdev[idx] + self.transformer.components_[:] = self.transformer.components_[idx] + + # Check orthogonality + dotps = [np.dot(*self.transformer.components_[[i, j]]) + for (i, j) in itertools.combinations(range(self.n_components), 2)] + if not np.allclose(dotps, 0, atol=1e-4): + print('SPCA components not orghogonal, max dot', np.abs(dotps).max()) + + def get_components(self): + var_ratio = self.stdev**2 / self.total_var + return self.transformer.components_, self.stdev, var_ratio # SPCA outputs are normalized + +def get_estimator(name, n_components, alpha): + if name == 'pca': + return PCAEstimator(n_components) + if name == 'ipca': + return IPCAEstimator(n_components) + elif name == 'fbpca': + return FacebookPCAEstimator(n_components) + elif name == 'ica': + return ICAEstimator(n_components) + elif name == 'spca': + return SPCAEstimator(n_components, alpha) + else: + raise RuntimeError('Unknown estimator') \ No newline at end of file diff --git a/interactive.py b/interactive.py new file mode 100644 index 0000000000000000000000000000000000000000..f2a95cf96173424b4939d0aa53b89e0460e2bc27 --- /dev/null +++ b/interactive.py @@ -0,0 +1,655 @@ +# Copyright 2020 Erik Härkönen. All rights reserved. +# This file is licensed to you under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. You may obtain a copy +# of the License at http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software distributed under +# the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS +# OF ANY KIND, either express or implied. See the License for the specific language +# governing permissions and limitations under the License. + +# An interactive glumpy (OpenGL) + tkinter viewer for interacting with principal components. +# Requires OpenGL and CUDA support for rendering. + +import torch +import numpy as np +import tkinter as tk +from tkinter import ttk +from types import SimpleNamespace +import matplotlib.pyplot as plt +from pathlib import Path +from os import makedirs +from models import get_instrumented_model +from config import Config +from decomposition import get_or_compute +from torch.nn.functional import interpolate +from TkTorchWindow import TorchImageView +from functools import partial +from platform import system +from PIL import Image +from utils import pad_frames, prettify_name +import pickle + +# For platform specific UI tweaks +is_windows = 'Windows' in system() +is_linux = 'Linux' in system() +is_mac = 'Darwin' in system() + +# Read input parameters +args = Config().from_args() + +# Don't bother without GPU +assert torch.cuda.is_available(), 'Interactive mode requires CUDA' + +# Use syntax from paper +def get_edit_name(idx, s, e, name=None): + return 'E({comp}, {edit_range}){edit_name}'.format( + comp = idx, + edit_range = f'{s}-{e}' if e > s else s, + edit_name = f': {name}' if name else '' + ) + +# Load or compute PCA basis vectors +def load_components(class_name, inst): + global components, state, use_named_latents + + config = args.from_dict({ 'output_class': class_name }) + dump_name = get_or_compute(config, inst) + data = np.load(dump_name, allow_pickle=False) + X_comp = data['act_comp'] + X_mean = data['act_mean'] + X_stdev = data['act_stdev'] + Z_comp = data['lat_comp'] + Z_mean = data['lat_mean'] + Z_stdev = data['lat_stdev'] + random_stdev_act = np.mean(data['random_stdevs']) + n_comp = X_comp.shape[0] + data.close() + + # Transfer to GPU + components = SimpleNamespace( + X_comp = torch.from_numpy(X_comp).cuda().float(), + X_mean = torch.from_numpy(X_mean).cuda().float(), + X_stdev = torch.from_numpy(X_stdev).cuda().float(), + Z_comp = torch.from_numpy(Z_comp).cuda().float(), + Z_stdev = torch.from_numpy(Z_stdev).cuda().float(), + Z_mean = torch.from_numpy(Z_mean).cuda().float(), + names = [f'Component {i}' for i in range(n_comp)], + latent_types = [model.latent_space_name()]*n_comp, + ranges = [(0, model.get_max_latents())]*n_comp, + ) + + state.component_class = class_name # invalidates cache + use_named_latents = False + print('Loaded components for', class_name, 'from', dump_name) + +# Load previously exported named components from +# directory specified with '--inputs=path/to/comp' +def load_named_components(path, class_name): + global components, state, use_named_latents + + import glob + matches = glob.glob(f'{path}/*.pkl') + + selected = [] + for dump_path in matches: + with open(dump_path, 'rb') as f: + data = pickle.load(f) + if data['model_name'] != model_name or data['output_class'] != class_name: + continue + + if data['latent_space'] != model.latent_space_name(): + print('Skipping', dump_path, '(wrong latent space)') + continue + + selected.append(data) + print('Using', dump_path) + + if len(selected) == 0: + raise RuntimeError('No valid components in given path.') + + comp_dict = { k : [] for k in ['X_comp', 'Z_comp', 'X_stdev', 'Z_stdev', 'names', 'types', 'layer_names', 'ranges', 'latent_types'] } + components = SimpleNamespace(**comp_dict) + + for d in selected: + s = d['edit_start'] + e = d['edit_end'] + title = get_edit_name(d['component_index'], s, e - 1, d['name']) # show inclusive + components.X_comp.append(torch.from_numpy(d['act_comp']).cuda()) + components.Z_comp.append(torch.from_numpy(d['lat_comp']).cuda()) + components.X_stdev.append(d['act_stdev']) + components.Z_stdev.append(d['lat_stdev']) + components.names.append(title) + components.types.append(d['edit_type']) + components.layer_names.append(d['decomposition']['layer']) # only for act + components.ranges.append((s, e)) + components.latent_types.append(d['latent_space']) # W or Z + + use_named_latents = True + print('Loaded named components') + +def setup_model(): + global model, inst, layer_name, model_name, feat_shape, args, class_name + + model_name = args.model + layer_name = args.layer + class_name = args.output_class + + # Speed up pytorch + torch.autograd.set_grad_enabled(False) + torch.backends.cudnn.benchmark = True + + # Load model + inst = get_instrumented_model(model_name, class_name, layer_name, torch.device('cuda'), use_w=args.use_w) + model = inst.model + + feat_shape = inst.feature_shape[layer_name] + sample_dims = np.prod(feat_shape) + + # Initialize + if args.inputs: + load_named_components(args.inputs, class_name) + else: + load_components(class_name, inst) + +# Project tensor 'X' onto orthonormal basis 'comp', return coordinates +def project_ortho(X, comp): + N = comp.shape[0] + coords = (comp.reshape(N, -1) * X.reshape(-1)).sum(dim=1) + return coords.reshape([N]+[1]*X.ndim) + +def zero_sliders(): + for v in ui_state.sliders: + v.set(0.0) + +def reset_sliders(zero_on_failure=True): + global ui_state + + mode = ui_state.mode.get() + + # Not orthogonal: need to solve least-norm problem + # Not batch size 1: one set of sliders not enough + # Not principal components: unsupported format + is_ortho = not (mode == 'latent' and model.latent_space_name() == 'Z') + is_single = state.z.shape[0] == 1 + is_pcs = not use_named_latents + + state.lat_slider_offset = 0 + state.act_slider_offset = 0 + + enabled = False + if not (enabled and is_ortho and is_single and is_pcs): + if zero_on_failure: + zero_sliders() + return + + if mode == 'activation': + val = state.base_act + mean = components.X_mean + comp = components.X_comp + stdev = components.X_stdev + else: + val = state.z + mean = components.Z_mean + comp = components.Z_comp + stdev = components.Z_stdev + + n_sliders = len(ui_state.sliders) + coords = project_ortho(val - mean, comp) + offset = torch.sum(coords[:n_sliders] * comp[:n_sliders], dim=0) + scaled_coords = (coords.view(-1) / stdev).detach().cpu().numpy() + + # Part representable by sliders + if mode == 'activation': + state.act_slider_offset = offset + else: + state.lat_slider_offset = offset + + for i in range(n_sliders): + ui_state.sliders[i].set(round(scaled_coords[i], ndigits=1)) + +def setup_ui(): + global root, toolbar, ui_state, app, canvas + + root = tk.Tk() + scale = 1.0 + app = TorchImageView(root, width=int(scale*1024), height=int(scale*1024), show_fps=False) + app.pack(fill=tk.BOTH, expand=tk.YES) + root.protocol("WM_DELETE_WINDOW", shutdown) + root.title('GANspace') + + toolbar = tk.Toplevel(root) + toolbar.protocol("WM_DELETE_WINDOW", shutdown) + toolbar.geometry("215x800+0+0") + toolbar.title('') + + N_COMPONENTS = min(70, len(components.names)) + ui_state = SimpleNamespace( + sliders = [tk.DoubleVar(value=0.0) for _ in range(N_COMPONENTS)], + scales = [], + truncation = tk.DoubleVar(value=0.9), + outclass = tk.StringVar(value=class_name), + random_seed = tk.StringVar(value='0'), + mode = tk.StringVar(value='latent'), + batch_size = tk.IntVar(value=1), # how many images to show in window + edit_layer_start = tk.IntVar(value=0), + edit_layer_end = tk.IntVar(value=model.get_max_latents() - 1), + slider_max_val = 10.0 + ) + + # Z vs activation mode button + #tk.Radiobutton(toolbar, text=f"Latent ({model.latent_space_name()})", variable=ui_state.mode, command=reset_sliders, value='latent').pack(fill="x") + #tk.Radiobutton(toolbar, text="Activation", variable=ui_state.mode, command=reset_sliders, value='activation').pack(fill="x") + + # Choose range where latents are modified + def set_min(val): + ui_state.edit_layer_start.set(min(int(val), ui_state.edit_layer_end.get())) + def set_max(val): + ui_state.edit_layer_end.set(max(int(val), ui_state.edit_layer_start.get())) + max_latent_idx = model.get_max_latents() - 1 + + if not use_named_latents: + slider_min = tk.Scale(toolbar, command=set_min, variable=ui_state.edit_layer_start, + label='Layer start', from_=0, to=max_latent_idx, orient=tk.HORIZONTAL).pack(fill="x") + slider_max = tk.Scale(toolbar, command=set_max, variable=ui_state.edit_layer_end, + label='Layer end', from_=0, to=max_latent_idx, orient=tk.HORIZONTAL).pack(fill="x") + + # Scrollable list of components + outer_frame = tk.Frame(toolbar, borderwidth=2, relief=tk.SUNKEN) + canvas = tk.Canvas(outer_frame, highlightthickness=0, borderwidth=0) + frame = tk.Frame(canvas) + vsb = tk.Scrollbar(outer_frame, orient="vertical", command=canvas.yview) + canvas.configure(yscrollcommand=vsb.set) + + vsb.pack(side="right", fill="y") + canvas.pack(side="left", fill="both", expand=True) + canvas.create_window((4,4), window=frame, anchor="nw") + + def onCanvasConfigure(event): + canvas.itemconfigure("all", width=event.width) + canvas.configure(scrollregion=canvas.bbox("all")) + canvas.bind("", onCanvasConfigure) + + def on_scroll(event): + delta = 1 if (event.num == 5 or event.delta < 0) else -1 + canvas.yview_scroll(delta, "units") + + canvas.bind_all("", on_scroll) + canvas.bind_all("", on_scroll) + canvas.bind_all("", on_scroll) + canvas.bind_all("", lambda event : handle_keypress(event.keysym_num)) + + # Sliders and buttons + for i in range(N_COMPONENTS): + inner = tk.Frame(frame, borderwidth=1, background="#aaaaaa") + scale = tk.Scale(inner, variable=ui_state.sliders[i], from_=-ui_state.slider_max_val, + to=ui_state.slider_max_val, resolution=0.1, orient=tk.HORIZONTAL, label=components.names[i]) + scale.pack(fill=tk.X, side=tk.LEFT, expand=True) + ui_state.scales.append(scale) # for changing label later + if not use_named_latents: + tk.Button(inner, text=f"Save", command=partial(export_direction, i, inner)).pack(fill=tk.Y, side=tk.RIGHT) + inner.pack(fill=tk.X) + + outer_frame.pack(fill="both", expand=True, pady=0) + + tk.Button(toolbar, text="Reset", command=reset_sliders).pack(anchor=tk.CENTER, fill=tk.X, padx=4, pady=4) + + tk.Scale(toolbar, variable=ui_state.truncation, from_=0.01, to=1.0, + resolution=0.01, orient=tk.HORIZONTAL, label='Truncation').pack(fill="x") + + tk.Scale(toolbar, variable=ui_state.batch_size, from_=1, to=9, + resolution=1, orient=tk.HORIZONTAL, label='Batch size').pack(fill="x") + + # Output class + frame = tk.Frame(toolbar) + tk.Label(frame, text="Class name").pack(fill="x", side="left") + tk.Entry(frame, textvariable=ui_state.outclass).pack(fill="x", side="right", expand=True, padx=5) + frame.pack(fill=tk.X, pady=3) + + # Random seed + def update_seed(): + seed_str = ui_state.random_seed.get() + if seed_str.isdigit(): + resample_latent(int(seed_str)) + frame = tk.Frame(toolbar) + tk.Label(frame, text="Seed").pack(fill="x", side="left") + tk.Entry(frame, textvariable=ui_state.random_seed, width=12).pack(fill="x", side="left", expand=True, padx=2) + tk.Button(frame, text="Update", command=update_seed).pack(fill="y", side="right", padx=3) + frame.pack(fill=tk.X, pady=3) + + # Get new latent or new components + tk.Button(toolbar, text="Resample latent", command=partial(resample_latent, None, False)).pack(anchor=tk.CENTER, fill=tk.X, padx=4, pady=4) + #tk.Button(toolbar, text="Recompute", command=recompute_components).pack(anchor=tk.CENTER, fill=tk.X) + +# App state +state = SimpleNamespace( + z=None, # current latent(s) + lat_slider_offset = 0, # part of lat that is explained by sliders + act_slider_offset = 0, # part of act that is explained by sliders + component_class=None, # name of current PCs' image class + seed=0, # Latent z_i generated by seed+i + base_act = None, # activation of considered layer given z +) + +def resample_latent(seed=None, only_style=False): + class_name = ui_state.outclass.get() + if class_name.isnumeric(): + class_name = int(class_name) + + if hasattr(model, 'is_valid_class'): + if not model.is_valid_class(class_name): + return + + model.set_output_class(class_name) + + B = ui_state.batch_size.get() + state.seed = np.random.randint(np.iinfo(np.int32).max - B) if seed is None else seed + ui_state.random_seed.set(str(state.seed)) + + # Use consecutive seeds along batch dimension (for easier reproducibility) + trunc = ui_state.truncation.get() + latents = [model.sample_latent(1, seed=state.seed + i, truncation=trunc) for i in range(B)] + + state.z = torch.cat(latents).clone().detach() # make leaf node + assert state.z.is_leaf, 'Latent is not leaf node!' + + if hasattr(model, 'truncation'): + model.truncation = ui_state.truncation.get() + print(f'Seeds: {state.seed} -> {state.seed + B - 1}' if B > 1 else f'Seed: {state.seed}') + + torch.manual_seed(state.seed) + model.partial_forward(state.z, layer_name) + state.base_act = inst.retained_features()[layer_name] + + reset_sliders(zero_on_failure=False) + + # Remove focus from text entry + canvas.focus_set() + +# Used to recompute after changing class of conditional model +def recompute_components(): + class_name = ui_state.outclass.get() + if class_name.isnumeric(): + class_name = int(class_name) + + if hasattr(model, 'is_valid_class'): + if not model.is_valid_class(class_name): + return + + if hasattr(model, 'set_output_class'): + model.set_output_class(class_name) + + load_components(class_name, inst) + +# Used to detect parameter changes for lazy recomputation +class ParamCache(): + def update(self, **kwargs): + dirty = False + for argname, val in kwargs.items(): + # Check pointer, then value + current = getattr(self, argname, 0) + if current is not val and pickle.dumps(current) != pickle.dumps(val): + setattr(self, argname, val) + dirty = True + return dirty + +cache = ParamCache() + +def l2norm(t): + return torch.norm(t.view(t.shape[0], -1), p=2, dim=1, keepdim=True) + +def apply_edit(z0, delta): + return z0 + delta + +def reposition_toolbar(): + size, X, Y = root.winfo_geometry().split('+') + W, H = size.split('x') + toolbar_W = toolbar.winfo_geometry().split('x')[0] + offset_y = -30 if is_linux else 0 # window title bar + toolbar.geometry(f'{toolbar_W}x{H}+{int(X)-int(toolbar_W)}+{int(Y)+offset_y}') + toolbar.update() + +def on_draw(): + global img + + n_comp = len(ui_state.sliders) + slider_vals = np.array([s.get() for s in ui_state.sliders], dtype=np.float32) + + # Run model sparingly + mode = ui_state.mode.get() + latent_start = ui_state.edit_layer_start.get() + latent_end = ui_state.edit_layer_end.get() + 1 # save as exclusive, show as inclusive + + if cache.update(coords=slider_vals, comp=state.component_class, mode=mode, z=state.z, s=latent_start, e=latent_end): + with torch.no_grad(): + z_base = state.z - state.lat_slider_offset + z_deltas = [0.0]*model.get_max_latents() + z_delta_global = 0.0 + + n_comp = slider_vals.size + act_deltas = {} + + if torch.is_tensor(state.act_slider_offset): + act_deltas[layer_name] = -state.act_slider_offset + + for space in components.latent_types: + assert space == model.latent_space_name(), \ + 'Cannot mix latent spaces (for now)' + + for c in range(n_comp): + coord = slider_vals[c] + if coord == 0: + continue + + edit_mode = components.types[c] if use_named_latents else mode + + # Activation offset + if edit_mode in ['activation', 'both']: + delta = components.X_comp[c] * components.X_stdev[c] * coord + name = components.layer_names[c] if use_named_latents else layer_name + act_deltas[name] = act_deltas.get(name, 0.0) + delta + + # Latent offset + if edit_mode in ['latent', 'both']: + delta = components.Z_comp[c] * components.Z_stdev[c] * coord + edit_range = components.ranges[c] if use_named_latents else (latent_start, latent_end) + full_range = (edit_range == (0, model.get_max_latents())) + + # Single or multiple offsets? + if full_range: + z_delta_global = z_delta_global + delta + else: + for l in range(*edit_range): + z_deltas[l] = z_deltas[l] + delta + + # Apply activation deltas + inst.remove_edits() + for layer, delta in act_deltas.items(): + inst.edit_layer(layer, offset=delta) + + # Evaluate + has_offsets = any(torch.is_tensor(t) for t in z_deltas) + z_final = apply_edit(z_base, z_delta_global) + if has_offsets: + z_final = [apply_edit(z_final, d) for d in z_deltas] + img = model.forward(z_final).clamp(0.0, 1.0) + + app.draw(img) + +# Save necessary data to disk for later loading +def export_direction(idx, button_frame): + name = tk.StringVar(value='') + num_strips = tk.IntVar(value=0) + strip_width = tk.IntVar(value=5) + + slider_values = np.array([s.get() for s in ui_state.sliders]) + slider_value = slider_values[idx] + if (slider_values != 0).sum() > 1: + print('Please modify only one slider') + return + elif slider_value == 0: + print('Modify selected slider to set usable range (currently 0)') + return + + popup = tk.Toplevel(root) + popup.geometry("200x200+0+0") + tk.Label(popup, text="Edit name").pack() + tk.Entry(popup, textvariable=name).pack(pady=5) + # tk.Scale(popup, from_=0, to=30, variable=num_strips, + # resolution=1, orient=tk.HORIZONTAL, length=200, label='Image strips to export').pack() + # tk.Scale(popup, from_=3, to=15, variable=strip_width, + # resolution=1, orient=tk.HORIZONTAL, length=200, label='Image strip width').pack() + tk.Button(popup, text='OK', command=popup.quit).pack() + + canceled = False + def on_close(): + nonlocal canceled + canceled = True + popup.quit() + + popup.protocol("WM_DELETE_WINDOW", on_close) + x = button_frame.winfo_rootx() + y = button_frame.winfo_rooty() + w = int(button_frame.winfo_geometry().split('x')[0]) + popup.geometry('%dx%d+%d+%d' % (180, 90, x + w, y)) + popup.mainloop() + popup.destroy() + + # Update slider name + label = get_edit_name(idx, ui_state.edit_layer_start.get(), + ui_state.edit_layer_end.get(), name.get()) + ui_state.scales[idx].config(label=label) + + if canceled: + return + + params = { + 'name': name.get(), + 'sigma_range': slider_value, + 'component_index': idx, + 'act_comp': components.X_comp[idx].detach().cpu().numpy(), + 'lat_comp': components.Z_comp[idx].detach().cpu().numpy(), # either Z or W + 'latent_space': model.latent_space_name(), + 'act_stdev': components.X_stdev[idx].item(), + 'lat_stdev': components.Z_stdev[idx].item(), + 'model_name': model_name, + 'output_class': ui_state.outclass.get(), # applied onto + 'decomposition': { + 'name': args.estimator, + 'components': args.components, + 'samples': args.n, + 'layer': args.layer, + 'class_name': state.component_class # computed from + }, + 'edit_type': ui_state.mode.get(), + 'truncation': ui_state.truncation.get(), + 'edit_start': ui_state.edit_layer_start.get(), + 'edit_end': ui_state.edit_layer_end.get() + 1, # show as inclusive, save as exclusive + 'example_seed': state.seed, + } + + edit_mode_str = params['edit_type'] + if edit_mode_str == 'latent': + edit_mode_str = model.latent_space_name().lower() + + comp_class = state.component_class + appl_class = params['output_class'] + if comp_class != appl_class: + comp_class = f'{comp_class}_onto_{appl_class}' + + file_ident = "{model}-{name}-{cls}-{est}-{mode}-{layer}-comp{idx}-range{start}-{end}".format( + model=model_name, + name=prettify_name(params['name']), + cls=comp_class, + est=args.estimator, + mode=edit_mode_str, + layer=args.layer, + idx=idx, + start=params['edit_start'], + end=params['edit_end'], + ) + + out_dir = Path(__file__).parent / 'out' / 'directions' + makedirs(out_dir / file_ident, exist_ok=True) + + with open(out_dir / f"{file_ident}.pkl", 'wb') as outfile: + pickle.dump(params, outfile) + + print(f'Direction "{name.get()}" saved as "{file_ident}.pkl"') + + batch_size = ui_state.batch_size.get() + len_padded = ((num_strips.get() - 1) // batch_size + 1) * batch_size + orig_seed = state.seed + + reset_sliders() + + # Limit max resolution + max_H = 512 + ratio = min(1.0, max_H / inst.output_shape[2]) + + strips = [[] for _ in range(len_padded)] + for b in range(0, len_padded, batch_size): + # Resample + resample_latent((orig_seed + b) % np.iinfo(np.int32).max) + + sigmas = np.linspace(slider_value, -slider_value, strip_width.get(), dtype=np.float32) + for sid, sigma in enumerate(sigmas): + ui_state.sliders[idx].set(sigma) + + # Advance and show results on screen + on_draw() + root.update() + app.update() + + batch_res = (255*img).byte().permute(0, 2, 3, 1).detach().cpu().numpy() + + for i, data in enumerate(batch_res): + # Save individual + name_nodots = file_ident.replace('.', '_') + outname = out_dir / file_ident / f"{name_nodots}_ex{b+i}_{sid}.png" + im = Image.fromarray(data) + im = im.resize((int(ratio*im.size[0]), int(ratio*im.size[1])), Image.ANTIALIAS) + im.save(outname) + strips[b+i].append(data) + + for i, strip in enumerate(strips[:num_strips.get()]): + print(f'Saving strip {i + 1}/{num_strips.get()}', end='\r', flush=True) + data = np.hstack(pad_frames(strip)) + im = Image.fromarray(data) + im = im.resize((int(ratio*im.size[0]), int(ratio*im.size[1])), Image.ANTIALIAS) + im.save(out_dir / file_ident / f"{file_ident}_ex{i}.png") + + # Reset to original state + resample_latent(orig_seed) + ui_state.sliders[idx].set(slider_value) + + +# Shared by glumpy and tkinter +def handle_keypress(code): + if code == 65307: # ESC + shutdown() + elif code == 65360: # HOME + reset_sliders() + elif code == 114: # R + pass #reset_sliders() + +def shutdown(): + global pending_close + pending_close = True + +def on_key_release(symbol, modifiers): + handle_keypress(symbol) + +if __name__=='__main__': + setup_model() + setup_ui() + resample_latent() + + pending_close = False + while not pending_close: + root.update() + app.update() + on_draw() + reposition_toolbar() + + root.destroy() \ No newline at end of file diff --git a/model_clip.py b/model_clip.py new file mode 100644 index 0000000000000000000000000000000000000000..232b7792eb97440642547bd462cf128df9243933 --- /dev/null +++ b/model_clip.py @@ -0,0 +1,436 @@ +from collections import OrderedDict +from typing import Tuple, Union + +import numpy as np +import torch +import torch.nn.functional as F +from torch import nn + + +class Bottleneck(nn.Module): + expansion = 4 + + def __init__(self, inplanes, planes, stride=1): + super().__init__() + + # all conv layers have stride 1. an avgpool is performed after the second convolution when stride > 1 + self.conv1 = nn.Conv2d(inplanes, planes, 1, bias=False) + self.bn1 = nn.BatchNorm2d(planes) + self.relu1 = nn.ReLU(inplace=True) + + self.conv2 = nn.Conv2d(planes, planes, 3, padding=1, bias=False) + self.bn2 = nn.BatchNorm2d(planes) + self.relu2 = nn.ReLU(inplace=True) + + self.avgpool = nn.AvgPool2d(stride) if stride > 1 else nn.Identity() + + self.conv3 = nn.Conv2d(planes, planes * self.expansion, 1, bias=False) + self.bn3 = nn.BatchNorm2d(planes * self.expansion) + self.relu3 = nn.ReLU(inplace=True) + + self.downsample = None + self.stride = stride + + if stride > 1 or inplanes != planes * Bottleneck.expansion: + # downsampling layer is prepended with an avgpool, and the subsequent convolution has stride 1 + self.downsample = nn.Sequential(OrderedDict([ + ("-1", nn.AvgPool2d(stride)), + ("0", nn.Conv2d(inplanes, planes * self.expansion, 1, stride=1, bias=False)), + ("1", nn.BatchNorm2d(planes * self.expansion)) + ])) + + def forward(self, x: torch.Tensor): + identity = x + + out = self.relu1(self.bn1(self.conv1(x))) + out = self.relu2(self.bn2(self.conv2(out))) + out = self.avgpool(out) + out = self.bn3(self.conv3(out)) + + if self.downsample is not None: + identity = self.downsample(x) + + out += identity + out = self.relu3(out) + return out + + +class AttentionPool2d(nn.Module): + def __init__(self, spacial_dim: int, embed_dim: int, num_heads: int, output_dim: int = None): + super().__init__() + self.positional_embedding = nn.Parameter(torch.randn(spacial_dim ** 2 + 1, embed_dim) / embed_dim ** 0.5) + self.k_proj = nn.Linear(embed_dim, embed_dim) + self.q_proj = nn.Linear(embed_dim, embed_dim) + self.v_proj = nn.Linear(embed_dim, embed_dim) + self.c_proj = nn.Linear(embed_dim, output_dim or embed_dim) + self.num_heads = num_heads + + def forward(self, x): + x = x.flatten(start_dim=2).permute(2, 0, 1) # NCHW -> (HW)NC + x = torch.cat([x.mean(dim=0, keepdim=True), x], dim=0) # (HW+1)NC + x = x + self.positional_embedding[:, None, :].to(x.dtype) # (HW+1)NC + x, _ = F.multi_head_attention_forward( + query=x[:1], key=x, value=x, + embed_dim_to_check=x.shape[-1], + num_heads=self.num_heads, + q_proj_weight=self.q_proj.weight, + k_proj_weight=self.k_proj.weight, + v_proj_weight=self.v_proj.weight, + in_proj_weight=None, + in_proj_bias=torch.cat([self.q_proj.bias, self.k_proj.bias, self.v_proj.bias]), + bias_k=None, + bias_v=None, + add_zero_attn=False, + dropout_p=0, + out_proj_weight=self.c_proj.weight, + out_proj_bias=self.c_proj.bias, + use_separate_proj_weight=True, + training=self.training, + need_weights=False + ) + return x.squeeze(0) + + +class ModifiedResNet(nn.Module): + """ + A ResNet class that is similar to torchvision's but contains the following changes: + - There are now 3 "stem" convolutions as opposed to 1, with an average pool instead of a max pool. + - Performs anti-aliasing strided convolutions, where an avgpool is prepended to convolutions with stride > 1 + - The final pooling layer is a QKV attention instead of an average pool + """ + + def __init__(self, layers, output_dim, heads, input_resolution=224, width=64): + super().__init__() + self.output_dim = output_dim + self.input_resolution = input_resolution + + # the 3-layer stem + self.conv1 = nn.Conv2d(3, width // 2, kernel_size=3, stride=2, padding=1, bias=False) + self.bn1 = nn.BatchNorm2d(width // 2) + self.relu1 = nn.ReLU(inplace=True) + self.conv2 = nn.Conv2d(width // 2, width // 2, kernel_size=3, padding=1, bias=False) + self.bn2 = nn.BatchNorm2d(width // 2) + self.relu2 = nn.ReLU(inplace=True) + self.conv3 = nn.Conv2d(width // 2, width, kernel_size=3, padding=1, bias=False) + self.bn3 = nn.BatchNorm2d(width) + self.relu3 = nn.ReLU(inplace=True) + self.avgpool = nn.AvgPool2d(2) + + # residual layers + self._inplanes = width # this is a *mutable* variable used during construction + self.layer1 = self._make_layer(width, layers[0]) + self.layer2 = self._make_layer(width * 2, layers[1], stride=2) + self.layer3 = self._make_layer(width * 4, layers[2], stride=2) + self.layer4 = self._make_layer(width * 8, layers[3], stride=2) + + embed_dim = width * 32 # the ResNet feature dimension + self.attnpool = AttentionPool2d(input_resolution // 32, embed_dim, heads, output_dim) + + def _make_layer(self, planes, blocks, stride=1): + layers = [Bottleneck(self._inplanes, planes, stride)] + + self._inplanes = planes * Bottleneck.expansion + for _ in range(1, blocks): + layers.append(Bottleneck(self._inplanes, planes)) + + return nn.Sequential(*layers) + + def forward(self, x): + def stem(x): + x = self.relu1(self.bn1(self.conv1(x))) + x = self.relu2(self.bn2(self.conv2(x))) + x = self.relu3(self.bn3(self.conv3(x))) + x = self.avgpool(x) + return x + + x = x.type(self.conv1.weight.dtype) + x = stem(x) + x = self.layer1(x) + x = self.layer2(x) + x = self.layer3(x) + x = self.layer4(x) + x = self.attnpool(x) + + return x + + +class LayerNorm(nn.LayerNorm): + """Subclass torch's LayerNorm to handle fp16.""" + + def forward(self, x: torch.Tensor): + orig_type = x.dtype + ret = super().forward(x.type(torch.float32)) + return ret.type(orig_type) + + +class QuickGELU(nn.Module): + def forward(self, x: torch.Tensor): + return x * torch.sigmoid(1.702 * x) + + +class ResidualAttentionBlock(nn.Module): + def __init__(self, d_model: int, n_head: int, attn_mask: torch.Tensor = None): + super().__init__() + + self.attn = nn.MultiheadAttention(d_model, n_head) + self.ln_1 = LayerNorm(d_model) + self.mlp = nn.Sequential(OrderedDict([ + ("c_fc", nn.Linear(d_model, d_model * 4)), + ("gelu", QuickGELU()), + ("c_proj", nn.Linear(d_model * 4, d_model)) + ])) + self.ln_2 = LayerNorm(d_model) + self.attn_mask = attn_mask + + def attention(self, x: torch.Tensor): + self.attn_mask = self.attn_mask.to(dtype=x.dtype, device=x.device) if self.attn_mask is not None else None + return self.attn(x, x, x, need_weights=False, attn_mask=self.attn_mask)[0] + + def forward(self, x: torch.Tensor): + x = x + self.attention(self.ln_1(x)) + x = x + self.mlp(self.ln_2(x)) + return x + + +class Transformer(nn.Module): + def __init__(self, width: int, layers: int, heads: int, attn_mask: torch.Tensor = None): + super().__init__() + self.width = width + self.layers = layers + self.resblocks = nn.Sequential(*[ResidualAttentionBlock(width, heads, attn_mask) for _ in range(layers)]) + + def forward(self, x: torch.Tensor): + return self.resblocks(x) + + +class VisionTransformer(nn.Module): + def __init__(self, input_resolution: int, patch_size: int, width: int, layers: int, heads: int, output_dim: int): + super().__init__() + self.input_resolution = input_resolution + self.output_dim = output_dim + self.conv1 = nn.Conv2d(in_channels=3, out_channels=width, kernel_size=patch_size, stride=patch_size, bias=False) + + scale = width ** -0.5 + self.class_embedding = nn.Parameter(scale * torch.randn(width)) + self.positional_embedding = nn.Parameter(scale * torch.randn((input_resolution // patch_size) ** 2 + 1, width)) + self.ln_pre = LayerNorm(width) + + self.transformer = Transformer(width, layers, heads) + + self.ln_post = LayerNorm(width) + self.proj = nn.Parameter(scale * torch.randn(width, output_dim)) + + def forward(self, x: torch.Tensor): + x = self.conv1(x) # shape = [*, width, grid, grid] + x = x.reshape(x.shape[0], x.shape[1], -1) # shape = [*, width, grid ** 2] + x = x.permute(0, 2, 1) # shape = [*, grid ** 2, width] + x = torch.cat([self.class_embedding.to(x.dtype) + torch.zeros(x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device), x], dim=1) # shape = [*, grid ** 2 + 1, width] + x = x + self.positional_embedding.to(x.dtype) + x = self.ln_pre(x) + + x = x.permute(1, 0, 2) # NLD -> LND + x = self.transformer(x) + x = x.permute(1, 0, 2) # LND -> NLD + + x = self.ln_post(x[:, 0, :]) + + if self.proj is not None: + x = x @ self.proj + + return x + + +class CLIP(nn.Module): + def __init__(self, + embed_dim: int, + # vision + image_resolution: int, + vision_layers: Union[Tuple[int, int, int, int], int], + vision_width: int, + vision_patch_size: int, + # text + context_length: int, + vocab_size: int, + transformer_width: int, + transformer_heads: int, + transformer_layers: int + ): + super().__init__() + + self.context_length = context_length + + if isinstance(vision_layers, (tuple, list)): + vision_heads = vision_width * 32 // 64 + self.visual = ModifiedResNet( + layers=vision_layers, + output_dim=embed_dim, + heads=vision_heads, + input_resolution=image_resolution, + width=vision_width + ) + else: + vision_heads = vision_width // 64 + self.visual = VisionTransformer( + input_resolution=image_resolution, + patch_size=vision_patch_size, + width=vision_width, + layers=vision_layers, + heads=vision_heads, + output_dim=embed_dim + ) + + self.transformer = Transformer( + width=transformer_width, + layers=transformer_layers, + heads=transformer_heads, + attn_mask=self.build_attention_mask() + ) + + self.vocab_size = vocab_size + self.token_embedding = nn.Embedding(vocab_size, transformer_width) + self.positional_embedding = nn.Parameter(torch.empty(self.context_length, transformer_width)) + self.ln_final = LayerNorm(transformer_width) + + self.text_projection = nn.Parameter(torch.empty(transformer_width, embed_dim)) + self.logit_scale = nn.Parameter(torch.ones([]) * np.log(1 / 0.07)) + + self.initialize_parameters() + + def initialize_parameters(self): + nn.init.normal_(self.token_embedding.weight, std=0.02) + nn.init.normal_(self.positional_embedding, std=0.01) + + if isinstance(self.visual, ModifiedResNet): + if self.visual.attnpool is not None: + std = self.visual.attnpool.c_proj.in_features ** -0.5 + nn.init.normal_(self.visual.attnpool.q_proj.weight, std=std) + nn.init.normal_(self.visual.attnpool.k_proj.weight, std=std) + nn.init.normal_(self.visual.attnpool.v_proj.weight, std=std) + nn.init.normal_(self.visual.attnpool.c_proj.weight, std=std) + + for resnet_block in [self.visual.layer1, self.visual.layer2, self.visual.layer3, self.visual.layer4]: + for name, param in resnet_block.named_parameters(): + if name.endswith("bn3.weight"): + nn.init.zeros_(param) + + proj_std = (self.transformer.width ** -0.5) * ((2 * self.transformer.layers) ** -0.5) + attn_std = self.transformer.width ** -0.5 + fc_std = (2 * self.transformer.width) ** -0.5 + for block in self.transformer.resblocks: + nn.init.normal_(block.attn.in_proj_weight, std=attn_std) + nn.init.normal_(block.attn.out_proj.weight, std=proj_std) + nn.init.normal_(block.mlp.c_fc.weight, std=fc_std) + nn.init.normal_(block.mlp.c_proj.weight, std=proj_std) + + if self.text_projection is not None: + nn.init.normal_(self.text_projection, std=self.transformer.width ** -0.5) + + def build_attention_mask(self): + # lazily create causal attention mask, with full attention between the vision tokens + # pytorch uses additive attention mask; fill with -inf + mask = torch.empty(self.context_length, self.context_length) + mask.fill_(float("-inf")) + mask.triu_(1) # zero out the lower diagonal + return mask + + @property + def dtype(self): + return self.visual.conv1.weight.dtype + + def encode_image(self, image): + return self.visual(image.type(self.dtype)) + + def encode_text(self, text): + x = self.token_embedding(text).type(self.dtype) # [batch_size, n_ctx, d_model] + + x = x + self.positional_embedding.type(self.dtype) + x = x.permute(1, 0, 2) # NLD -> LND + x = self.transformer(x) + x = x.permute(1, 0, 2) # LND -> NLD + x = self.ln_final(x).type(self.dtype) + + # x.shape = [batch_size, n_ctx, transformer.width] + # take features from the eot embedding (eot_token is the highest number in each sequence) + x = x[torch.arange(x.shape[0]), text.argmax(dim=-1)] @ self.text_projection + + return x + + def forward(self, image, text): + image_features = self.encode_image(image) + text_features = self.encode_text(text) + + # normalized features + image_features = image_features / image_features.norm(dim=1, keepdim=True) + text_features = text_features / text_features.norm(dim=1, keepdim=True) + + # cosine similarity as logits + logit_scale = self.logit_scale.exp() + logits_per_image = logit_scale * image_features @ text_features.t() + logits_per_text = logits_per_image.t() + + # shape = [global_batch_size, global_batch_size] + return logits_per_image, logits_per_text + + +def convert_weights(model: nn.Module): + """Convert applicable model parameters to fp16""" + + def _convert_weights_to_fp16(l): + if isinstance(l, (nn.Conv1d, nn.Conv2d, nn.Linear)): + l.weight.data = l.weight.data.half() + if l.bias is not None: + l.bias.data = l.bias.data.half() + + if isinstance(l, nn.MultiheadAttention): + for attr in [*[f"{s}_proj_weight" for s in ["in", "q", "k", "v"]], "in_proj_bias", "bias_k", "bias_v"]: + tensor = getattr(l, attr) + if tensor is not None: + tensor.data = tensor.data.half() + + for name in ["text_projection", "proj"]: + if hasattr(l, name): + attr = getattr(l, name) + if attr is not None: + attr.data = attr.data.half() + + model.apply(_convert_weights_to_fp16) + + +def build_model(state_dict: dict): + vit = "visual.proj" in state_dict + + if vit: + vision_width = state_dict["visual.conv1.weight"].shape[0] + vision_layers = len([k for k in state_dict.keys() if k.startswith("visual.") and k.endswith(".attn.in_proj_weight")]) + vision_patch_size = state_dict["visual.conv1.weight"].shape[-1] + grid_size = round((state_dict["visual.positional_embedding"].shape[0] - 1) ** 0.5) + image_resolution = vision_patch_size * grid_size + else: + counts: list = [len(set(k.split(".")[2] for k in state_dict if k.startswith(f"visual.layer{b}"))) for b in [1, 2, 3, 4]] + vision_layers = tuple(counts) + vision_width = state_dict["visual.layer1.0.conv1.weight"].shape[0] + output_width = round((state_dict["visual.attnpool.positional_embedding"].shape[0] - 1) ** 0.5) + vision_patch_size = None + assert output_width ** 2 + 1 == state_dict["visual.attnpool.positional_embedding"].shape[0] + image_resolution = output_width * 32 + + embed_dim = state_dict["text_projection"].shape[1] + context_length = state_dict["positional_embedding"].shape[0] + vocab_size = state_dict["token_embedding.weight"].shape[0] + transformer_width = state_dict["ln_final.weight"].shape[0] + transformer_heads = transformer_width // 64 + transformer_layers = len(set(k.split(".")[2] for k in state_dict if k.startswith("transformer.resblocks"))) + + model = CLIP( + embed_dim, + image_resolution, vision_layers, vision_width, vision_patch_size, + context_length, vocab_size, transformer_width, transformer_heads, transformer_layers + ) + + for key in ["input_resolution", "context_length", "vocab_size"]: + if key in state_dict: + del state_dict[key] + + convert_weights(model) + model.load_state_dict(state_dict) + return model.eval() diff --git a/models/__init__.py b/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9941a7bb29d1b9a0a00f9cf90ddf2c48f1e38ed9 --- /dev/null +++ b/models/__init__.py @@ -0,0 +1,11 @@ +# Copyright 2020 Erik Härkönen. All rights reserved. +# This file is licensed to you under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. You may obtain a copy +# of the License at http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software distributed under +# the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS +# OF ANY KIND, either express or implied. See the License for the specific language +# governing permissions and limitations under the License. + +from .wrappers import * \ No newline at end of file diff --git a/models/__pycache__/__init__.cpython-310.pyc b/models/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0c5502dc445cfd0b5ad1835c0248210f5b3c4fe6 Binary files /dev/null and b/models/__pycache__/__init__.cpython-310.pyc differ diff --git a/models/__pycache__/wrappers.cpython-310.pyc b/models/__pycache__/wrappers.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..36d33d56d305933383320633a2d9281f3a296a36 Binary files /dev/null and b/models/__pycache__/wrappers.cpython-310.pyc differ diff --git a/models/biggan/__init__.py b/models/biggan/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..583509736f3503bc277d5d2e2a69f445f7df8517 --- /dev/null +++ b/models/biggan/__init__.py @@ -0,0 +1,8 @@ +from pathlib import Path +import sys + +module_path = Path(__file__).parent / 'pytorch_biggan' +sys.path.append(str(module_path.resolve())) +from pytorch_pretrained_biggan import * +from pytorch_pretrained_biggan.model import GenBlock +from pytorch_pretrained_biggan.file_utils import http_get, s3_get \ No newline at end of file diff --git a/models/biggan/__pycache__/__init__.cpython-310.pyc b/models/biggan/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3f4d2804128cedaad43c465241033c59e2375f91 Binary files /dev/null and b/models/biggan/__pycache__/__init__.cpython-310.pyc differ diff --git a/models/biggan/pytorch_biggan/.gitignore b/models/biggan/pytorch_biggan/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..05ddaa0a3bbca712670120686fcda8001db5ae3f --- /dev/null +++ b/models/biggan/pytorch_biggan/.gitignore @@ -0,0 +1,110 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# pyenv +.python-version + +# celery beat schedule file +celerybeat-schedule + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ + +# vscode +.vscode/ + +# models +models/ \ No newline at end of file diff --git a/models/biggan/pytorch_biggan/LICENSE b/models/biggan/pytorch_biggan/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f42fd227a7d2d8baf6637ac59ca80449c2b35812 --- /dev/null +++ b/models/biggan/pytorch_biggan/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2020 Erik Härkönen + +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/models/biggan/pytorch_biggan/MANIFEST.in b/models/biggan/pytorch_biggan/MANIFEST.in new file mode 100644 index 0000000000000000000000000000000000000000..1aba38f67a2211cf5b09466d7b411206cb7223bf --- /dev/null +++ b/models/biggan/pytorch_biggan/MANIFEST.in @@ -0,0 +1 @@ +include LICENSE diff --git a/models/biggan/pytorch_biggan/README.md b/models/biggan/pytorch_biggan/README.md new file mode 100644 index 0000000000000000000000000000000000000000..deaa6c2a145a02a211ca45c59541ff88ce4da23c --- /dev/null +++ b/models/biggan/pytorch_biggan/README.md @@ -0,0 +1,227 @@ +# BigStyleGAN +This is a copy of HuggingFace's BigGAN implementation, with the addition of layerwise latent inputs. + +# PyTorch pretrained BigGAN +An op-for-op PyTorch reimplementation of DeepMind's BigGAN model with the pre-trained weights from DeepMind. + +## Introduction + +This repository contains an op-for-op PyTorch reimplementation of DeepMind's BigGAN that was released with the paper [Large Scale GAN Training for High Fidelity Natural Image Synthesis](https://openreview.net/forum?id=B1xsqj09Fm) by Andrew Brock, Jeff Donahue and Karen Simonyan. + +This PyTorch implementation of BigGAN is provided with the [pretrained 128x128, 256x256 and 512x512 models by DeepMind](https://tfhub.dev/deepmind/biggan-deep-128/1). We also provide the scripts used to download and convert these models from the TensorFlow Hub models. + +This reimplementation was done from the raw computation graph of the Tensorflow version and behave similarly to the TensorFlow version (variance of the output difference of the order of 1e-5). + +This implementation currently only contains the generator as the weights of the discriminator were not released (although the structure of the discriminator is very similar to the generator so it could be added pretty easily. Tell me if you want to do a PR on that, I would be happy to help.) + +## Installation + +This repo was tested on Python 3.6 and PyTorch 1.0.1 + +PyTorch pretrained BigGAN can be installed from pip as follows: +```bash +pip install pytorch-pretrained-biggan +``` + +If you simply want to play with the GAN this should be enough. + +If you want to use the conversion scripts and the imagenet utilities, additional requirements are needed, in particular TensorFlow and NLTK. To install all the requirements please use the `full_requirements.txt` file: +```bash +git clone https://github.com/huggingface/pytorch-pretrained-BigGAN.git +cd pytorch-pretrained-BigGAN +pip install -r full_requirements.txt +``` + +## Models + +This repository provide direct and simple access to the pretrained "deep" versions of BigGAN for 128, 256 and 512 pixels resolutions as described in the [associated publication](https://openreview.net/forum?id=B1xsqj09Fm). +Here are some details on the models: + +- `BigGAN-deep-128`: a 50.4M parameters model generating 128x128 pixels images, the model dump weights 201 MB, +- `BigGAN-deep-256`: a 55.9M parameters model generating 256x256 pixels images, the model dump weights 224 MB, +- `BigGAN-deep-512`: a 56.2M parameters model generating 512x512 pixels images, the model dump weights 225 MB. + +Please refer to Appendix B of the paper for details on the architectures. + +All models comprise pre-computed batch norm statistics for 51 truncation values between 0 and 1 (see Appendix C.1 in the paper for details). + +## Usage + +Here is a quick-start example using `BigGAN` with a pre-trained model. + +See the [doc section](#doc) below for details on these classes and methods. + +```python +import torch +from pytorch_pretrained_biggan import (BigGAN, one_hot_from_names, truncated_noise_sample, + save_as_images, display_in_terminal) + +# OPTIONAL: if you want to have more information on what's happening, activate the logger as follows +import logging +logging.basicConfig(level=logging.INFO) + +# Load pre-trained model tokenizer (vocabulary) +model = BigGAN.from_pretrained('biggan-deep-256') + +# Prepare a input +truncation = 0.4 +class_vector = one_hot_from_names(['soap bubble', 'coffee', 'mushroom'], batch_size=3) +noise_vector = truncated_noise_sample(truncation=truncation, batch_size=3) + +# All in tensors +noise_vector = torch.from_numpy(noise_vector) +class_vector = torch.from_numpy(class_vector) + +# If you have a GPU, put everything on cuda +noise_vector = noise_vector.to('cuda') +class_vector = class_vector.to('cuda') +model.to('cuda') + +# Generate an image +with torch.no_grad(): + output = model(noise_vector, class_vector, truncation) + +# If you have a GPU put back on CPU +output = output.to('cpu') + +# If you have a sixtel compatible terminal you can display the images in the terminal +# (see https://github.com/saitoha/libsixel for details) +display_in_terminal(output) + +# Save results as png images +save_as_images(output) +``` + +![output_0](assets/output_0.png) +![output_1](assets/output_1.png) +![output_2](assets/output_2.png) + +## Doc + +### Loading DeepMind's pre-trained weights + +To load one of DeepMind's pre-trained models, instantiate a `BigGAN` model with `from_pretrained()` as: + +```python +model = BigGAN.from_pretrained(PRE_TRAINED_MODEL_NAME_OR_PATH, cache_dir=None) +``` + +where + +- `PRE_TRAINED_MODEL_NAME_OR_PATH` is either: + + - the shortcut name of a Google AI's or OpenAI's pre-trained model selected in the list: + + - `biggan-deep-128`: 12-layer, 768-hidden, 12-heads, 110M parameters + - `biggan-deep-256`: 24-layer, 1024-hidden, 16-heads, 340M parameters + - `biggan-deep-512`: 12-layer, 768-hidden, 12-heads , 110M parameters + + - a path or url to a pretrained model archive containing: + + - `config.json`: a configuration file for the model, and + - `pytorch_model.bin` a PyTorch dump of a pre-trained instance of `BigGAN` (saved with the usual `torch.save()`). + + If `PRE_TRAINED_MODEL_NAME_OR_PATH` is a shortcut name, the pre-trained weights will be downloaded from AWS S3 (see the links [here](pytorch_pretrained_biggan/model.py)) and stored in a cache folder to avoid future download (the cache folder can be found at `~/.pytorch_pretrained_biggan/`). +- `cache_dir` can be an optional path to a specific directory to download and cache the pre-trained model weights. + +### Configuration + +`BigGANConfig` is a class to store and load BigGAN configurations. It's defined in [`config.py`](./pytorch_pretrained_biggan/config.py). + +Here are some details on the attributes: + +- `output_dim`: output resolution of the GAN (128, 256 or 512) for the pre-trained models, +- `z_dim`: size of the noise vector (128 for the pre-trained models). +- `class_embed_dim`: size of the class embedding vectors (128 for the pre-trained models). +- `channel_width`: size of each channel (128 for the pre-trained models). +- `num_classes`: number of classes in the training dataset, like imagenet (1000 for the pre-trained models). +- `layers`: A list of layers definition. Each definition for a layer is a triple of [up-sample in the layer ? (bool), number of input channels (int), number of output channels (int)] +- `attention_layer_position`: Position of the self-attention layer in the layer hierarchy (8 for the pre-trained models). +- `eps`: epsilon value to use for spectral and batch normalization layers (1e-4 for the pre-trained models). +- `n_stats`: number of pre-computed statistics for the batch normalization layers associated to various truncation values between 0 and 1 (51 for the pre-trained models). + +### Model + +`BigGAN` is a PyTorch model (`torch.nn.Module`) of BigGAN defined in [`model.py`](./pytorch_pretrained_biggan/model.py). This model comprises the class embeddings (a linear layer) and the generator with a series of convolutions and conditional batch norms. The discriminator is currently not implemented since pre-trained weights have not been released for it. + +The inputs and output are **identical to the TensorFlow model inputs and outputs**. + +We detail them here. + +`BigGAN` takes as *inputs*: + +- `z`: a torch.FloatTensor of shape [batch_size, config.z_dim] with noise sampled from a truncated normal distribution, and +- `class_label`: an optional torch.LongTensor of shape [batch_size, sequence_length] with the token types indices selected in [0, 1]. Type 0 corresponds to a `sentence A` and type 1 corresponds to a `sentence B` token (see BERT paper for more details). +- `truncation`: a float between 0 (not comprised) and 1. The truncation of the truncated normal used for creating the noise vector. This truncation value is used to selecte between a set of pre-computed statistics (means and variances) for the batch norm layers. + +`BigGAN` *outputs* an array of shape [batch_size, 3, resolution, resolution] where resolution is 128, 256 or 512 depending of the model: + +### Utilities: Images, Noise, Imagenet classes + +We provide a few utility method to use the model. They are defined in [`utils.py`](./pytorch_pretrained_biggan/utils.py). + +Here are some details on these methods: + +- `truncated_noise_sample(batch_size=1, dim_z=128, truncation=1., seed=None)`: + + Create a truncated noise vector. + - Params: + - batch_size: batch size. + - dim_z: dimension of z + - truncation: truncation value to use + - seed: seed for the random generator + - Output: + array of shape (batch_size, dim_z) + +- `convert_to_images(obj)`: + + Convert an output tensor from BigGAN in a list of images. + - Params: + - obj: tensor or numpy array of shape (batch_size, channels, height, width) + - Output: + - list of Pillow Images of size (height, width) + +- `save_as_images(obj, file_name='output')`: + + Convert and save an output tensor from BigGAN in a list of saved images. + - Params: + - obj: tensor or numpy array of shape (batch_size, channels, height, width) + - file_name: path and beggingin of filename to save. + Images will be saved as `file_name_{image_number}.png` + +- `display_in_terminal(obj)`: + + Convert and display an output tensor from BigGAN in the terminal. This function use `libsixel` and will only work in a libsixel-compatible terminal. Please refer to https://github.com/saitoha/libsixel for more details. + - Params: + - obj: tensor or numpy array of shape (batch_size, channels, height, width) + - file_name: path and beggingin of filename to save. + Images will be saved as `file_name_{image_number}.png` + +- `one_hot_from_int(int_or_list, batch_size=1)`: + + Create a one-hot vector from a class index or a list of class indices. + - Params: + - int_or_list: int, or list of int, of the imagenet classes (between 0 and 999) + - batch_size: batch size. + - If int_or_list is an int create a batch of identical classes. + - If int_or_list is a list, we should have `len(int_or_list) == batch_size` + - Output: + - array of shape (batch_size, 1000) + +- `one_hot_from_names(class_name, batch_size=1)`: + + Create a one-hot vector from the name of an imagenet class ('tennis ball', 'daisy', ...). We use NLTK's wordnet search to try to find the relevant synset of ImageNet and take the first one. If we can't find it direcly, we look at the hyponyms and hypernyms of the class name. + - Params: + - class_name: string containing the name of an imagenet object. + - Output: + - array of shape (batch_size, 1000) + +## Download and conversion scripts + +Scripts to download and convert the TensorFlow models from TensorFlow Hub are provided in [./scripts](./scripts/). + +The scripts can be used directly as: +```bash +./scripts/download_tf_hub_models.sh +./scripts/convert_tf_hub_models.sh +``` diff --git a/models/biggan/pytorch_biggan/assets/output_0.png b/models/biggan/pytorch_biggan/assets/output_0.png new file mode 100644 index 0000000000000000000000000000000000000000..72080456d0cedfe261a92adee665c5336be2ca33 Binary files /dev/null and b/models/biggan/pytorch_biggan/assets/output_0.png differ diff --git a/models/biggan/pytorch_biggan/assets/output_1.png b/models/biggan/pytorch_biggan/assets/output_1.png new file mode 100644 index 0000000000000000000000000000000000000000..ba89ee0d5d25d784a425fd333463491e71b5baad Binary files /dev/null and b/models/biggan/pytorch_biggan/assets/output_1.png differ diff --git a/models/biggan/pytorch_biggan/assets/output_2.png b/models/biggan/pytorch_biggan/assets/output_2.png new file mode 100644 index 0000000000000000000000000000000000000000..df25ee283e20e0c3fb7d2ffc91e82eb17acba498 Binary files /dev/null and b/models/biggan/pytorch_biggan/assets/output_2.png differ diff --git a/models/biggan/pytorch_biggan/full_requirements.txt b/models/biggan/pytorch_biggan/full_requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..f2dee70711e7f07b644d83d776cb4a2503999ff7 --- /dev/null +++ b/models/biggan/pytorch_biggan/full_requirements.txt @@ -0,0 +1,5 @@ +tensorflow +tensorflow-hub +Pillow +nltk +libsixel-python \ No newline at end of file diff --git a/models/biggan/pytorch_biggan/pytorch_pretrained_biggan/__init__.py b/models/biggan/pytorch_biggan/pytorch_pretrained_biggan/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b570848421afd921fae635569c97d0f8f5b33c80 --- /dev/null +++ b/models/biggan/pytorch_biggan/pytorch_pretrained_biggan/__init__.py @@ -0,0 +1,6 @@ +from .config import BigGANConfig +from .model import BigGAN +from .file_utils import PYTORCH_PRETRAINED_BIGGAN_CACHE, cached_path +from .utils import (truncated_noise_sample, save_as_images, + convert_to_images, display_in_terminal, + one_hot_from_int, one_hot_from_names) diff --git a/models/biggan/pytorch_biggan/pytorch_pretrained_biggan/config.py b/models/biggan/pytorch_biggan/pytorch_pretrained_biggan/config.py new file mode 100644 index 0000000000000000000000000000000000000000..454236a4bfa0d11fda0d52e0ce9b2926f8c32d30 --- /dev/null +++ b/models/biggan/pytorch_biggan/pytorch_pretrained_biggan/config.py @@ -0,0 +1,70 @@ +# coding: utf-8 +""" +BigGAN config. +""" +from __future__ import (absolute_import, division, print_function, unicode_literals) + +import copy +import json + +class BigGANConfig(object): + """ Configuration class to store the configuration of a `BigGAN`. + Defaults are for the 128x128 model. + layers tuple are (up-sample in the layer ?, input channels, output channels) + """ + def __init__(self, + output_dim=128, + z_dim=128, + class_embed_dim=128, + channel_width=128, + num_classes=1000, + layers=[(False, 16, 16), + (True, 16, 16), + (False, 16, 16), + (True, 16, 8), + (False, 8, 8), + (True, 8, 4), + (False, 4, 4), + (True, 4, 2), + (False, 2, 2), + (True, 2, 1)], + attention_layer_position=8, + eps=1e-4, + n_stats=51): + """Constructs BigGANConfig. """ + self.output_dim = output_dim + self.z_dim = z_dim + self.class_embed_dim = class_embed_dim + self.channel_width = channel_width + self.num_classes = num_classes + self.layers = layers + self.attention_layer_position = attention_layer_position + self.eps = eps + self.n_stats = n_stats + + @classmethod + def from_dict(cls, json_object): + """Constructs a `BigGANConfig` from a Python dictionary of parameters.""" + config = BigGANConfig() + for key, value in json_object.items(): + config.__dict__[key] = value + return config + + @classmethod + def from_json_file(cls, json_file): + """Constructs a `BigGANConfig` from a json file of parameters.""" + with open(json_file, "r", encoding='utf-8') as reader: + text = reader.read() + return cls.from_dict(json.loads(text)) + + def __repr__(self): + return str(self.to_json_string()) + + def to_dict(self): + """Serializes this instance to a Python dictionary.""" + output = copy.deepcopy(self.__dict__) + return output + + def to_json_string(self): + """Serializes this instance to a JSON string.""" + return json.dumps(self.to_dict(), indent=2, sort_keys=True) + "\n" diff --git a/models/biggan/pytorch_biggan/pytorch_pretrained_biggan/convert_tf_to_pytorch.py b/models/biggan/pytorch_biggan/pytorch_pretrained_biggan/convert_tf_to_pytorch.py new file mode 100644 index 0000000000000000000000000000000000000000..7ccb787dec188e9dbd9ea31288c049c1bdb30f95 --- /dev/null +++ b/models/biggan/pytorch_biggan/pytorch_pretrained_biggan/convert_tf_to_pytorch.py @@ -0,0 +1,312 @@ +# coding: utf-8 +""" +Convert a TF Hub model for BigGAN in a PT one. +""" +from __future__ import (absolute_import, division, print_function, unicode_literals) + +from itertools import chain + +import os +import argparse +import logging +import numpy as np +import torch +import torch.nn as nn +import torch.nn.functional as F +from torch.nn.functional import normalize + +from .model import BigGAN, WEIGHTS_NAME, CONFIG_NAME +from .config import BigGANConfig + +logger = logging.getLogger(__name__) + + +def extract_batch_norm_stats(tf_model_path, batch_norm_stats_path=None): + try: + import numpy as np + import tensorflow as tf + import tensorflow_hub as hub + except ImportError: + raise ImportError("Loading a TensorFlow models in PyTorch, requires TensorFlow and TF Hub to be installed. " + "Please see https://www.tensorflow.org/install/ for installation instructions for TensorFlow. " + "And see https://github.com/tensorflow/hub for installing Hub. " + "Probably pip install tensorflow tensorflow-hub") + tf.reset_default_graph() + logger.info('Loading BigGAN module from: {}'.format(tf_model_path)) + module = hub.Module(tf_model_path) + inputs = {k: tf.placeholder(v.dtype, v.get_shape().as_list(), k) + for k, v in module.get_input_info_dict().items()} + output = module(inputs) + + initializer = tf.global_variables_initializer() + sess = tf.Session() + stacks = sum(((i*10 + 1, i*10 + 3, i*10 + 6, i*10 + 8) for i in range(50)), ()) + numpy_stacks = [] + for i in stacks: + logger.info("Retrieving module_apply_default/stack_{}".format(i)) + try: + stack_var = tf.get_default_graph().get_tensor_by_name("module_apply_default/stack_%d:0" % i) + except KeyError: + break # We have all the stats + numpy_stacks.append(sess.run(stack_var)) + + if batch_norm_stats_path is not None: + torch.save(numpy_stacks, batch_norm_stats_path) + else: + return numpy_stacks + + +def build_tf_to_pytorch_map(model, config): + """ Build a map from TF variables to PyTorch modules. """ + tf_to_pt_map = {} + + # Embeddings and GenZ + tf_to_pt_map.update({'linear/w/ema_0.9999': model.embeddings.weight, + 'Generator/GenZ/G_linear/b/ema_0.9999': model.generator.gen_z.bias, + 'Generator/GenZ/G_linear/w/ema_0.9999': model.generator.gen_z.weight_orig, + 'Generator/GenZ/G_linear/u0': model.generator.gen_z.weight_u}) + + # GBlock blocks + model_layer_idx = 0 + for i, (up, in_channels, out_channels) in enumerate(config.layers): + if i == config.attention_layer_position: + model_layer_idx += 1 + layer_str = "Generator/GBlock_%d/" % i if i > 0 else "Generator/GBlock/" + layer_pnt = model.generator.layers[model_layer_idx] + for i in range(4): # Batchnorms + batch_str = layer_str + ("BatchNorm_%d/" % i if i > 0 else "BatchNorm/") + batch_pnt = getattr(layer_pnt, 'bn_%d' % i) + for name in ('offset', 'scale'): + sub_module_str = batch_str + name + "/" + sub_module_pnt = getattr(batch_pnt, name) + tf_to_pt_map.update({sub_module_str + "w/ema_0.9999": sub_module_pnt.weight_orig, + sub_module_str + "u0": sub_module_pnt.weight_u}) + for i in range(4): # Convolutions + conv_str = layer_str + "conv%d/" % i + conv_pnt = getattr(layer_pnt, 'conv_%d' % i) + tf_to_pt_map.update({conv_str + "b/ema_0.9999": conv_pnt.bias, + conv_str + "w/ema_0.9999": conv_pnt.weight_orig, + conv_str + "u0": conv_pnt.weight_u}) + model_layer_idx += 1 + + # Attention block + layer_str = "Generator/attention/" + layer_pnt = model.generator.layers[config.attention_layer_position] + tf_to_pt_map.update({layer_str + "gamma/ema_0.9999": layer_pnt.gamma}) + for pt_name, tf_name in zip(['snconv1x1_g', 'snconv1x1_o_conv', 'snconv1x1_phi', 'snconv1x1_theta'], + ['g/', 'o_conv/', 'phi/', 'theta/']): + sub_module_str = layer_str + tf_name + sub_module_pnt = getattr(layer_pnt, pt_name) + tf_to_pt_map.update({sub_module_str + "w/ema_0.9999": sub_module_pnt.weight_orig, + sub_module_str + "u0": sub_module_pnt.weight_u}) + + # final batch norm and conv to rgb + layer_str = "Generator/BatchNorm/" + layer_pnt = model.generator.bn + tf_to_pt_map.update({layer_str + "offset/ema_0.9999": layer_pnt.bias, + layer_str + "scale/ema_0.9999": layer_pnt.weight}) + layer_str = "Generator/conv_to_rgb/" + layer_pnt = model.generator.conv_to_rgb + tf_to_pt_map.update({layer_str + "b/ema_0.9999": layer_pnt.bias, + layer_str + "w/ema_0.9999": layer_pnt.weight_orig, + layer_str + "u0": layer_pnt.weight_u}) + return tf_to_pt_map + + +def load_tf_weights_in_biggan(model, config, tf_model_path, batch_norm_stats_path=None): + """ Load tf checkpoints and standing statistics in a pytorch model + """ + try: + import numpy as np + import tensorflow as tf + except ImportError: + raise ImportError("Loading a TensorFlow models in PyTorch, requires TensorFlow to be installed. Please see " + "https://www.tensorflow.org/install/ for installation instructions.") + # Load weights from TF model + checkpoint_path = tf_model_path + "/variables/variables" + init_vars = tf.train.list_variables(checkpoint_path) + from pprint import pprint + pprint(init_vars) + + # Extract batch norm statistics from model if needed + if batch_norm_stats_path: + stats = torch.load(batch_norm_stats_path) + else: + logger.info("Extracting batch norm stats") + stats = extract_batch_norm_stats(tf_model_path) + + # Build TF to PyTorch weights loading map + tf_to_pt_map = build_tf_to_pytorch_map(model, config) + + tf_weights = {} + for name in tf_to_pt_map.keys(): + array = tf.train.load_variable(checkpoint_path, name) + tf_weights[name] = array + # logger.info("Loading TF weight {} with shape {}".format(name, array.shape)) + + # Load parameters + with torch.no_grad(): + pt_params_pnt = set() + for name, pointer in tf_to_pt_map.items(): + array = tf_weights[name] + if pointer.dim() == 1: + if pointer.dim() < array.ndim: + array = np.squeeze(array) + elif pointer.dim() == 2: # Weights + array = np.transpose(array) + elif pointer.dim() == 4: # Convolutions + array = np.transpose(array, (3, 2, 0, 1)) + else: + raise "Wrong dimensions to adjust: " + str((pointer.shape, array.shape)) + if pointer.shape != array.shape: + raise ValueError("Wrong dimensions: " + str((pointer.shape, array.shape))) + logger.info("Initialize PyTorch weight {} with shape {}".format(name, pointer.shape)) + pointer.data = torch.from_numpy(array) if isinstance(array, np.ndarray) else torch.tensor(array) + tf_weights.pop(name, None) + pt_params_pnt.add(pointer.data_ptr()) + + # Prepare SpectralNorm buffers by running one step of Spectral Norm (no need to train the model): + for module in model.modules(): + for n, buffer in module.named_buffers(): + if n == 'weight_v': + weight_mat = module.weight_orig + weight_mat = weight_mat.reshape(weight_mat.size(0), -1) + u = module.weight_u + + v = normalize(torch.mv(weight_mat.t(), u), dim=0, eps=config.eps) + buffer.data = v + pt_params_pnt.add(buffer.data_ptr()) + + u = normalize(torch.mv(weight_mat, v), dim=0, eps=config.eps) + module.weight_u.data = u + pt_params_pnt.add(module.weight_u.data_ptr()) + + # Load batch norm statistics + index = 0 + for layer in model.generator.layers: + if not hasattr(layer, 'bn_0'): + continue + for i in range(4): # Batchnorms + bn_pointer = getattr(layer, 'bn_%d' % i) + pointer = bn_pointer.running_means + if pointer.shape != stats[index].shape: + raise "Wrong dimensions: " + str((pointer.shape, stats[index].shape)) + pointer.data = torch.from_numpy(stats[index]) + pt_params_pnt.add(pointer.data_ptr()) + + pointer = bn_pointer.running_vars + if pointer.shape != stats[index+1].shape: + raise "Wrong dimensions: " + str((pointer.shape, stats[index].shape)) + pointer.data = torch.from_numpy(stats[index+1]) + pt_params_pnt.add(pointer.data_ptr()) + + index += 2 + + bn_pointer = model.generator.bn + pointer = bn_pointer.running_means + if pointer.shape != stats[index].shape: + raise "Wrong dimensions: " + str((pointer.shape, stats[index].shape)) + pointer.data = torch.from_numpy(stats[index]) + pt_params_pnt.add(pointer.data_ptr()) + + pointer = bn_pointer.running_vars + if pointer.shape != stats[index+1].shape: + raise "Wrong dimensions: " + str((pointer.shape, stats[index].shape)) + pointer.data = torch.from_numpy(stats[index+1]) + pt_params_pnt.add(pointer.data_ptr()) + + remaining_params = list(n for n, t in chain(model.named_parameters(), model.named_buffers()) \ + if t.data_ptr() not in pt_params_pnt) + + logger.info("TF Weights not copied to PyTorch model: {} -".format(', '.join(tf_weights.keys()))) + logger.info("Remanining parameters/buffers from PyTorch model: {} -".format(', '.join(remaining_params))) + + return model + + +BigGAN128 = BigGANConfig(output_dim=128, z_dim=128, class_embed_dim=128, channel_width=128, num_classes=1000, + layers=[(False, 16, 16), + (True, 16, 16), + (False, 16, 16), + (True, 16, 8), + (False, 8, 8), + (True, 8, 4), + (False, 4, 4), + (True, 4, 2), + (False, 2, 2), + (True, 2, 1)], + attention_layer_position=8, eps=1e-4, n_stats=51) + +BigGAN256 = BigGANConfig(output_dim=256, z_dim=128, class_embed_dim=128, channel_width=128, num_classes=1000, + layers=[(False, 16, 16), + (True, 16, 16), + (False, 16, 16), + (True, 16, 8), + (False, 8, 8), + (True, 8, 8), + (False, 8, 8), + (True, 8, 4), + (False, 4, 4), + (True, 4, 2), + (False, 2, 2), + (True, 2, 1)], + attention_layer_position=8, eps=1e-4, n_stats=51) + +BigGAN512 = BigGANConfig(output_dim=512, z_dim=128, class_embed_dim=128, channel_width=128, num_classes=1000, + layers=[(False, 16, 16), + (True, 16, 16), + (False, 16, 16), + (True, 16, 8), + (False, 8, 8), + (True, 8, 8), + (False, 8, 8), + (True, 8, 4), + (False, 4, 4), + (True, 4, 2), + (False, 2, 2), + (True, 2, 1), + (False, 1, 1), + (True, 1, 1)], + attention_layer_position=8, eps=1e-4, n_stats=51) + + +def main(): + parser = argparse.ArgumentParser(description="Convert a BigGAN TF Hub model in a PyTorch model") + parser.add_argument("--model_type", type=str, default="", required=True, + help="BigGAN model type (128, 256, 512)") + parser.add_argument("--tf_model_path", type=str, default="", required=True, + help="Path of the downloaded TF Hub model") + parser.add_argument("--pt_save_path", type=str, default="", + help="Folder to save the PyTorch model (default: Folder of the TF Hub model)") + parser.add_argument("--batch_norm_stats_path", type=str, default="", + help="Path of previously extracted batch norm statistics") + args = parser.parse_args() + + logging.basicConfig(level=logging.INFO) + + if not args.pt_save_path: + args.pt_save_path = args.tf_model_path + + if args.model_type == "128": + config = BigGAN128 + elif args.model_type == "256": + config = BigGAN256 + elif args.model_type == "512": + config = BigGAN512 + else: + raise ValueError("model_type should be one of 128, 256 or 512") + + model = BigGAN(config) + model = load_tf_weights_in_biggan(model, config, args.tf_model_path, args.batch_norm_stats_path) + + model_save_path = os.path.join(args.pt_save_path, WEIGHTS_NAME) + config_save_path = os.path.join(args.pt_save_path, CONFIG_NAME) + + logger.info("Save model dump to {}".format(model_save_path)) + torch.save(model.state_dict(), model_save_path) + logger.info("Save configuration file to {}".format(config_save_path)) + with open(config_save_path, "w", encoding="utf-8") as f: + f.write(config.to_json_string()) + +if __name__ == "__main__": + main() diff --git a/models/biggan/pytorch_biggan/pytorch_pretrained_biggan/file_utils.py b/models/biggan/pytorch_biggan/pytorch_pretrained_biggan/file_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..41624cad6d7b44c028f3ef1fb541add4956b4601 --- /dev/null +++ b/models/biggan/pytorch_biggan/pytorch_pretrained_biggan/file_utils.py @@ -0,0 +1,249 @@ +""" +Utilities for working with the local dataset cache. +This file is adapted from the AllenNLP library at https://github.com/allenai/allennlp +Copyright by the AllenNLP authors. +""" +from __future__ import (absolute_import, division, print_function, unicode_literals) + +import json +import logging +import os +import shutil +import tempfile +from functools import wraps +from hashlib import sha256 +import sys +from io import open + +import boto3 +import requests +from botocore.exceptions import ClientError +from tqdm import tqdm + +try: + from urllib.parse import urlparse +except ImportError: + from urlparse import urlparse + +try: + from pathlib import Path + PYTORCH_PRETRAINED_BIGGAN_CACHE = Path(os.getenv('PYTORCH_PRETRAINED_BIGGAN_CACHE', + Path.home() / '.pytorch_pretrained_biggan')) +except (AttributeError, ImportError): + PYTORCH_PRETRAINED_BIGGAN_CACHE = os.getenv('PYTORCH_PRETRAINED_BIGGAN_CACHE', + os.path.join(os.path.expanduser("~"), '.pytorch_pretrained_biggan')) + +logger = logging.getLogger(__name__) # pylint: disable=invalid-name + + +def url_to_filename(url, etag=None): + """ + Convert `url` into a hashed filename in a repeatable way. + If `etag` is specified, append its hash to the url's, delimited + by a period. + """ + url_bytes = url.encode('utf-8') + url_hash = sha256(url_bytes) + filename = url_hash.hexdigest() + + if etag: + etag_bytes = etag.encode('utf-8') + etag_hash = sha256(etag_bytes) + filename += '.' + etag_hash.hexdigest() + + return filename + + +def filename_to_url(filename, cache_dir=None): + """ + Return the url and etag (which may be ``None``) stored for `filename`. + Raise ``EnvironmentError`` if `filename` or its stored metadata do not exist. + """ + if cache_dir is None: + cache_dir = PYTORCH_PRETRAINED_BIGGAN_CACHE + if sys.version_info[0] == 3 and isinstance(cache_dir, Path): + cache_dir = str(cache_dir) + + cache_path = os.path.join(cache_dir, filename) + if not os.path.exists(cache_path): + raise EnvironmentError("file {} not found".format(cache_path)) + + meta_path = cache_path + '.json' + if not os.path.exists(meta_path): + raise EnvironmentError("file {} not found".format(meta_path)) + + with open(meta_path, encoding="utf-8") as meta_file: + metadata = json.load(meta_file) + url = metadata['url'] + etag = metadata['etag'] + + return url, etag + + +def cached_path(url_or_filename, cache_dir=None): + """ + Given something that might be a URL (or might be a local path), + determine which. If it's a URL, download the file and cache it, and + return the path to the cached file. If it's already a local path, + make sure the file exists and then return the path. + """ + if cache_dir is None: + cache_dir = PYTORCH_PRETRAINED_BIGGAN_CACHE + if sys.version_info[0] == 3 and isinstance(url_or_filename, Path): + url_or_filename = str(url_or_filename) + if sys.version_info[0] == 3 and isinstance(cache_dir, Path): + cache_dir = str(cache_dir) + + parsed = urlparse(url_or_filename) + + if parsed.scheme in ('http', 'https', 's3'): + # URL, so get it from the cache (downloading if necessary) + return get_from_cache(url_or_filename, cache_dir) + elif os.path.exists(url_or_filename): + # File, and it exists. + return url_or_filename + elif parsed.scheme == '': + # File, but it doesn't exist. + raise EnvironmentError("file {} not found".format(url_or_filename)) + else: + # Something unknown + raise ValueError("unable to parse {} as a URL or as a local path".format(url_or_filename)) + + +def split_s3_path(url): + """Split a full s3 path into the bucket name and path.""" + parsed = urlparse(url) + if not parsed.netloc or not parsed.path: + raise ValueError("bad s3 path {}".format(url)) + bucket_name = parsed.netloc + s3_path = parsed.path + # Remove '/' at beginning of path. + if s3_path.startswith("/"): + s3_path = s3_path[1:] + return bucket_name, s3_path + + +def s3_request(func): + """ + Wrapper function for s3 requests in order to create more helpful error + messages. + """ + + @wraps(func) + def wrapper(url, *args, **kwargs): + try: + return func(url, *args, **kwargs) + except ClientError as exc: + if int(exc.response["Error"]["Code"]) == 404: + raise EnvironmentError("file {} not found".format(url)) + else: + raise + + return wrapper + + +@s3_request +def s3_etag(url): + """Check ETag on S3 object.""" + s3_resource = boto3.resource("s3") + bucket_name, s3_path = split_s3_path(url) + s3_object = s3_resource.Object(bucket_name, s3_path) + return s3_object.e_tag + + +@s3_request +def s3_get(url, temp_file): + """Pull a file directly from S3.""" + s3_resource = boto3.resource("s3") + bucket_name, s3_path = split_s3_path(url) + s3_resource.Bucket(bucket_name).download_fileobj(s3_path, temp_file) + + +def http_get(url, temp_file): + req = requests.get(url, stream=True) + content_length = req.headers.get('Content-Length') + total = int(content_length) if content_length is not None else None + progress = tqdm(unit="B", total=total) + for chunk in req.iter_content(chunk_size=1024): + if chunk: # filter out keep-alive new chunks + progress.update(len(chunk)) + temp_file.write(chunk) + progress.close() + + +def get_from_cache(url, cache_dir=None): + """ + Given a URL, look for the corresponding dataset in the local cache. + If it's not there, download it. Then return the path to the cached file. + """ + if cache_dir is None: + cache_dir = PYTORCH_PRETRAINED_BIGGAN_CACHE + if sys.version_info[0] == 3 and isinstance(cache_dir, Path): + cache_dir = str(cache_dir) + + if not os.path.exists(cache_dir): + os.makedirs(cache_dir) + + # Get eTag to add to filename, if it exists. + if url.startswith("s3://"): + etag = s3_etag(url) + else: + response = requests.head(url, allow_redirects=True) + if response.status_code != 200: + raise IOError("HEAD request failed for url {} with status code {}" + .format(url, response.status_code)) + etag = response.headers.get("ETag") + + filename = url_to_filename(url, etag) + + # get cache path to put the file + cache_path = os.path.join(cache_dir, filename) + + if not os.path.exists(cache_path): + # Download to temporary file, then copy to cache dir once finished. + # Otherwise you get corrupt cache entries if the download gets interrupted. + with tempfile.NamedTemporaryFile() as temp_file: + logger.info("%s not found in cache, downloading to %s", url, temp_file.name) + + # GET file object + if url.startswith("s3://"): + s3_get(url, temp_file) + else: + http_get(url, temp_file) + + # we are copying the file before closing it, so flush to avoid truncation + temp_file.flush() + # shutil.copyfileobj() starts at the current position, so go to the start + temp_file.seek(0) + + logger.info("copying %s to cache at %s", temp_file.name, cache_path) + with open(cache_path, 'wb') as cache_file: + shutil.copyfileobj(temp_file, cache_file) + + logger.info("creating metadata file for %s", cache_path) + meta = {'url': url, 'etag': etag} + meta_path = cache_path + '.json' + with open(meta_path, 'w', encoding="utf-8") as meta_file: + json.dump(meta, meta_file) + + logger.info("removing temp file %s", temp_file.name) + + return cache_path + + +def read_set_from_file(filename): + ''' + Extract a de-duped collection (set) of text from a file. + Expected file format is one item per line. + ''' + collection = set() + with open(filename, 'r', encoding='utf-8') as file_: + for line in file_: + collection.add(line.rstrip()) + return collection + + +def get_file_extension(path, dot=True, lower=True): + ext = os.path.splitext(path)[1] + ext = ext if dot else ext[1:] + return ext.lower() if lower else ext diff --git a/models/biggan/pytorch_biggan/pytorch_pretrained_biggan/model.py b/models/biggan/pytorch_biggan/pytorch_pretrained_biggan/model.py new file mode 100644 index 0000000000000000000000000000000000000000..22488abd92182a878fa1bedadfed50afbb472d3e --- /dev/null +++ b/models/biggan/pytorch_biggan/pytorch_pretrained_biggan/model.py @@ -0,0 +1,345 @@ +# coding: utf-8 +""" BigGAN PyTorch model. + From "Large Scale GAN Training for High Fidelity Natural Image Synthesis" + By Andrew Brocky, Jeff Donahuey and Karen Simonyan. + https://openreview.net/forum?id=B1xsqj09Fm + + PyTorch version implemented from the computational graph of the TF Hub module for BigGAN. + Some part of the code are adapted from https://github.com/brain-research/self-attention-gan + + This version only comprises the generator (since the discriminator's weights are not released). + This version only comprises the "deep" version of BigGAN (see publication). + + Modified by Erik Härkönen: + * Added support for per-layer latent vectors +""" +from __future__ import (absolute_import, division, print_function, unicode_literals) + +import os +import logging +import math + +import numpy as np +import torch +import torch.nn as nn +import torch.nn.functional as F + +from .config import BigGANConfig +from .file_utils import cached_path + +logger = logging.getLogger(__name__) + +PRETRAINED_MODEL_ARCHIVE_MAP = { + 'biggan-deep-128': "https://s3.amazonaws.com/models.huggingface.co/biggan/biggan-deep-128-pytorch_model.bin", + 'biggan-deep-256': "https://s3.amazonaws.com/models.huggingface.co/biggan/biggan-deep-256-pytorch_model.bin", + 'biggan-deep-512': "https://s3.amazonaws.com/models.huggingface.co/biggan/biggan-deep-512-pytorch_model.bin", +} + +PRETRAINED_CONFIG_ARCHIVE_MAP = { + 'biggan-deep-128': "https://s3.amazonaws.com/models.huggingface.co/biggan/biggan-deep-128-config.json", + 'biggan-deep-256': "https://s3.amazonaws.com/models.huggingface.co/biggan/biggan-deep-256-config.json", + 'biggan-deep-512': "https://s3.amazonaws.com/models.huggingface.co/biggan/biggan-deep-512-config.json", +} + +WEIGHTS_NAME = 'pytorch_model.bin' +CONFIG_NAME = 'config.json' + + +def snconv2d(eps=1e-12, **kwargs): + return nn.utils.spectral_norm(nn.Conv2d(**kwargs), eps=eps) + +def snlinear(eps=1e-12, **kwargs): + return nn.utils.spectral_norm(nn.Linear(**kwargs), eps=eps) + +def sn_embedding(eps=1e-12, **kwargs): + return nn.utils.spectral_norm(nn.Embedding(**kwargs), eps=eps) + +class SelfAttn(nn.Module): + """ Self attention Layer""" + def __init__(self, in_channels, eps=1e-12): + super(SelfAttn, self).__init__() + self.in_channels = in_channels + self.snconv1x1_theta = snconv2d(in_channels=in_channels, out_channels=in_channels//8, + kernel_size=1, bias=False, eps=eps) + self.snconv1x1_phi = snconv2d(in_channels=in_channels, out_channels=in_channels//8, + kernel_size=1, bias=False, eps=eps) + self.snconv1x1_g = snconv2d(in_channels=in_channels, out_channels=in_channels//2, + kernel_size=1, bias=False, eps=eps) + self.snconv1x1_o_conv = snconv2d(in_channels=in_channels//2, out_channels=in_channels, + kernel_size=1, bias=False, eps=eps) + self.maxpool = nn.MaxPool2d(2, stride=2, padding=0) + self.softmax = nn.Softmax(dim=-1) + self.gamma = nn.Parameter(torch.zeros(1)) + + def forward(self, x): + _, ch, h, w = x.size() + # Theta path + theta = self.snconv1x1_theta(x) + theta = theta.view(-1, ch//8, h*w) + # Phi path + phi = self.snconv1x1_phi(x) + phi = self.maxpool(phi) + phi = phi.view(-1, ch//8, h*w//4) + # Attn map + attn = torch.bmm(theta.permute(0, 2, 1), phi) + attn = self.softmax(attn) + # g path + g = self.snconv1x1_g(x) + g = self.maxpool(g) + g = g.view(-1, ch//2, h*w//4) + # Attn_g - o_conv + attn_g = torch.bmm(g, attn.permute(0, 2, 1)) + attn_g = attn_g.view(-1, ch//2, h, w) + attn_g = self.snconv1x1_o_conv(attn_g) + # Out + out = x + self.gamma*attn_g + return out + + +class BigGANBatchNorm(nn.Module): + """ This is a batch norm module that can handle conditional input and can be provided with pre-computed + activation means and variances for various truncation parameters. + + We cannot just rely on torch.batch_norm since it cannot handle + batched weights (pytorch 1.0.1). We computate batch_norm our-self without updating running means and variances. + If you want to train this model you should add running means and variance computation logic. + """ + def __init__(self, num_features, condition_vector_dim=None, n_stats=51, eps=1e-4, conditional=True): + super(BigGANBatchNorm, self).__init__() + self.num_features = num_features + self.eps = eps + self.conditional = conditional + + # We use pre-computed statistics for n_stats values of truncation between 0 and 1 + self.register_buffer('running_means', torch.zeros(n_stats, num_features)) + self.register_buffer('running_vars', torch.ones(n_stats, num_features)) + self.step_size = 1.0 / (n_stats - 1) + + if conditional: + assert condition_vector_dim is not None + self.scale = snlinear(in_features=condition_vector_dim, out_features=num_features, bias=False, eps=eps) + self.offset = snlinear(in_features=condition_vector_dim, out_features=num_features, bias=False, eps=eps) + else: + self.weight = torch.nn.Parameter(torch.Tensor(num_features)) + self.bias = torch.nn.Parameter(torch.Tensor(num_features)) + + def forward(self, x, truncation, condition_vector=None): + # Retreive pre-computed statistics associated to this truncation + coef, start_idx = math.modf(truncation / self.step_size) + start_idx = int(start_idx) + if coef != 0.0: # Interpolate + running_mean = self.running_means[start_idx] * coef + self.running_means[start_idx + 1] * (1 - coef) + running_var = self.running_vars[start_idx] * coef + self.running_vars[start_idx + 1] * (1 - coef) + else: + running_mean = self.running_means[start_idx] + running_var = self.running_vars[start_idx] + + if self.conditional: + running_mean = running_mean.unsqueeze(0).unsqueeze(-1).unsqueeze(-1) + running_var = running_var.unsqueeze(0).unsqueeze(-1).unsqueeze(-1) + + weight = 1 + self.scale(condition_vector).unsqueeze(-1).unsqueeze(-1) + bias = self.offset(condition_vector).unsqueeze(-1).unsqueeze(-1) + + out = (x - running_mean) / torch.sqrt(running_var + self.eps) * weight + bias + else: + out = F.batch_norm(x, running_mean, running_var, self.weight, self.bias, + training=False, momentum=0.0, eps=self.eps) + + return out + + +class GenBlock(nn.Module): + def __init__(self, in_size, out_size, condition_vector_dim, reduction_factor=4, up_sample=False, + n_stats=51, eps=1e-12): + super(GenBlock, self).__init__() + self.up_sample = up_sample + self.drop_channels = (in_size != out_size) + middle_size = in_size // reduction_factor + + self.bn_0 = BigGANBatchNorm(in_size, condition_vector_dim, n_stats=n_stats, eps=eps, conditional=True) + self.conv_0 = snconv2d(in_channels=in_size, out_channels=middle_size, kernel_size=1, eps=eps) + + self.bn_1 = BigGANBatchNorm(middle_size, condition_vector_dim, n_stats=n_stats, eps=eps, conditional=True) + self.conv_1 = snconv2d(in_channels=middle_size, out_channels=middle_size, kernel_size=3, padding=1, eps=eps) + + self.bn_2 = BigGANBatchNorm(middle_size, condition_vector_dim, n_stats=n_stats, eps=eps, conditional=True) + self.conv_2 = snconv2d(in_channels=middle_size, out_channels=middle_size, kernel_size=3, padding=1, eps=eps) + + self.bn_3 = BigGANBatchNorm(middle_size, condition_vector_dim, n_stats=n_stats, eps=eps, conditional=True) + self.conv_3 = snconv2d(in_channels=middle_size, out_channels=out_size, kernel_size=1, eps=eps) + + self.relu = nn.ReLU() + + def forward(self, x, cond_vector, truncation): + x0 = x + + x = self.bn_0(x, truncation, cond_vector) + x = self.relu(x) + x = self.conv_0(x) + + x = self.bn_1(x, truncation, cond_vector) + x = self.relu(x) + if self.up_sample: + x = F.interpolate(x, scale_factor=2, mode='nearest') + x = self.conv_1(x) + + x = self.bn_2(x, truncation, cond_vector) + x = self.relu(x) + x = self.conv_2(x) + + x = self.bn_3(x, truncation, cond_vector) + x = self.relu(x) + x = self.conv_3(x) + + if self.drop_channels: + new_channels = x0.shape[1] // 2 + x0 = x0[:, :new_channels, ...] + if self.up_sample: + x0 = F.interpolate(x0, scale_factor=2, mode='nearest') + + out = x + x0 + return out + +class Generator(nn.Module): + def __init__(self, config): + super(Generator, self).__init__() + self.config = config + ch = config.channel_width + condition_vector_dim = config.z_dim * 2 + + self.gen_z = snlinear(in_features=condition_vector_dim, + out_features=4 * 4 * 16 * ch, eps=config.eps) + + layers = [] + for i, layer in enumerate(config.layers): + if i == config.attention_layer_position: + layers.append(SelfAttn(ch*layer[1], eps=config.eps)) + layers.append(GenBlock(ch*layer[1], + ch*layer[2], + condition_vector_dim, + up_sample=layer[0], + n_stats=config.n_stats, + eps=config.eps)) + self.layers = nn.ModuleList(layers) + + self.bn = BigGANBatchNorm(ch, n_stats=config.n_stats, eps=config.eps, conditional=False) + self.relu = nn.ReLU() + self.conv_to_rgb = snconv2d(in_channels=ch, out_channels=ch, kernel_size=3, padding=1, eps=config.eps) + self.tanh = nn.Tanh() + + def forward(self, cond_vector, truncation): + z = self.gen_z(cond_vector[0]) + + # We use this conversion step to be able to use TF weights: + # TF convention on shape is [batch, height, width, channels] + # PT convention on shape is [batch, channels, height, width] + z = z.view(-1, 4, 4, 16 * self.config.channel_width) + z = z.permute(0, 3, 1, 2).contiguous() + + cond_idx = 1 + for i, layer in enumerate(self.layers): + if isinstance(layer, GenBlock): + z = layer(z, cond_vector[cond_idx], truncation) + cond_idx += 1 + else: + z = layer(z) + + z = self.bn(z, truncation) + z = self.relu(z) + z = self.conv_to_rgb(z) + z = z[:, :3, ...] + z = self.tanh(z) + return z + +class BigGAN(nn.Module): + """BigGAN Generator.""" + + @classmethod + def from_pretrained(cls, pretrained_model_name_or_path, cache_dir=None, *inputs, **kwargs): + if pretrained_model_name_or_path in PRETRAINED_MODEL_ARCHIVE_MAP: + model_file = PRETRAINED_MODEL_ARCHIVE_MAP[pretrained_model_name_or_path] + config_file = PRETRAINED_CONFIG_ARCHIVE_MAP[pretrained_model_name_or_path] + else: + model_file = os.path.join(pretrained_model_name_or_path, WEIGHTS_NAME) + config_file = os.path.join(pretrained_model_name_or_path, CONFIG_NAME) + + try: + resolved_model_file = cached_path(model_file, cache_dir=cache_dir) + resolved_config_file = cached_path(config_file, cache_dir=cache_dir) + except EnvironmentError: + logger.error("Wrong model name, should be a valid path to a folder containing " + "a {} file and a {} file or a model name in {}".format( + WEIGHTS_NAME, CONFIG_NAME, PRETRAINED_MODEL_ARCHIVE_MAP.keys())) + raise + + logger.info("loading model {} from cache at {}".format(pretrained_model_name_or_path, resolved_model_file)) + + # Load config + config = BigGANConfig.from_json_file(resolved_config_file) + logger.info("Model config {}".format(config)) + + # Instantiate model. + model = cls(config, *inputs, **kwargs) + state_dict = torch.load(resolved_model_file, map_location='cpu' if not torch.cuda.is_available() else None) + model.load_state_dict(state_dict, strict=False) + return model + + def __init__(self, config): + super(BigGAN, self).__init__() + self.config = config + self.embeddings = nn.Linear(config.num_classes, config.z_dim, bias=False) + self.generator = Generator(config) + self.n_latents = len(config.layers) + 1 # one for gen_z + one per layer + + def forward(self, z, class_label, truncation): + assert 0 < truncation <= 1 + + if not isinstance(z, list): + z = self.n_latents*[z] + + if isinstance(class_label, list): + embed = [self.embeddings(l) for l in class_label] + else: + embed = self.n_latents*[self.embeddings(class_label)] + + assert len(z) == self.n_latents, f'Expected {self.n_latents} latents, got {len(z)}' + assert len(embed) == self.n_latents, f'Expected {self.n_latents} class vectors, got {len(class_label)}' + + cond_vectors = [torch.cat((z, e), dim=1) for (z, e) in zip(z, embed)] + z = self.generator(cond_vectors, truncation) + return z + + +if __name__ == "__main__": + import PIL + from .utils import truncated_noise_sample, save_as_images, one_hot_from_names + from .convert_tf_to_pytorch import load_tf_weights_in_biggan + + load_cache = False + cache_path = './saved_model.pt' + config = BigGANConfig() + model = BigGAN(config) + if not load_cache: + model = load_tf_weights_in_biggan(model, config, './models/model_128/', './models/model_128/batchnorms_stats.bin') + torch.save(model.state_dict(), cache_path) + else: + model.load_state_dict(torch.load(cache_path)) + + model.eval() + + truncation = 0.4 + noise = truncated_noise_sample(batch_size=2, truncation=truncation) + label = one_hot_from_names('diver', batch_size=2) + + # Tests + # noise = np.zeros((1, 128)) + # label = [983] + + noise = torch.tensor(noise, dtype=torch.float) + label = torch.tensor(label, dtype=torch.float) + with torch.no_grad(): + outputs = model(noise, label, truncation) + print(outputs.shape) + + save_as_images(outputs) diff --git a/models/biggan/pytorch_biggan/pytorch_pretrained_biggan/utils.py b/models/biggan/pytorch_biggan/pytorch_pretrained_biggan/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..3b9edbef3ecc9bf85092f4e670eb5fac8a3b4616 --- /dev/null +++ b/models/biggan/pytorch_biggan/pytorch_pretrained_biggan/utils.py @@ -0,0 +1,216 @@ +# coding: utf-8 +""" BigGAN utilities to prepare truncated noise samples and convert/save/display output images. + Also comprise ImageNet utilities to prepare one hot input vectors for ImageNet classes. + We use Wordnet so you can just input a name in a string and automatically get a corresponding + imagenet class if it exists (or a hypo/hypernym exists in imagenet). +""" +from __future__ import absolute_import, division, print_function, unicode_literals + +import json +import logging +from io import BytesIO + +import numpy as np +from scipy.stats import truncnorm + +logger = logging.getLogger(__name__) + +NUM_CLASSES = 1000 + + +def truncated_noise_sample(batch_size=1, dim_z=128, truncation=1., seed=None): + """ Create a truncated noise vector. + Params: + batch_size: batch size. + dim_z: dimension of z + truncation: truncation value to use + seed: seed for the random generator + Output: + array of shape (batch_size, dim_z) + """ + state = None if seed is None else np.random.RandomState(seed) + values = truncnorm.rvs(-2, 2, size=(batch_size, dim_z), random_state=state).astype(np.float32) + return truncation * values + + +def convert_to_images(obj): + """ Convert an output tensor from BigGAN in a list of images. + Params: + obj: tensor or numpy array of shape (batch_size, channels, height, width) + Output: + list of Pillow Images of size (height, width) + """ + try: + import PIL + except ImportError: + raise ImportError("Please install Pillow to use images: pip install Pillow") + + if not isinstance(obj, np.ndarray): + obj = obj.detach().numpy() + + obj = obj.transpose((0, 2, 3, 1)) + obj = np.clip(((obj + 1) / 2.0) * 256, 0, 255) + + img = [] + for i, out in enumerate(obj): + out_array = np.asarray(np.uint8(out), dtype=np.uint8) + img.append(PIL.Image.fromarray(out_array)) + return img + + +def save_as_images(obj, file_name='output'): + """ Convert and save an output tensor from BigGAN in a list of saved images. + Params: + obj: tensor or numpy array of shape (batch_size, channels, height, width) + file_name: path and beggingin of filename to save. + Images will be saved as `file_name_{image_number}.png` + """ + img = convert_to_images(obj) + + for i, out in enumerate(img): + current_file_name = file_name + '_%d.png' % i + logger.info("Saving image to {}".format(current_file_name)) + out.save(current_file_name, 'png') + + +def display_in_terminal(obj): + """ Convert and display an output tensor from BigGAN in the terminal. + This function use `libsixel` and will only work in a libsixel-compatible terminal. + Please refer to https://github.com/saitoha/libsixel for more details. + + Params: + obj: tensor or numpy array of shape (batch_size, channels, height, width) + file_name: path and beggingin of filename to save. + Images will be saved as `file_name_{image_number}.png` + """ + try: + import PIL + from libsixel import (sixel_output_new, sixel_dither_new, sixel_dither_initialize, + sixel_dither_set_palette, sixel_dither_set_pixelformat, + sixel_dither_get, sixel_encode, sixel_dither_unref, + sixel_output_unref, SIXEL_PIXELFORMAT_RGBA8888, + SIXEL_PIXELFORMAT_RGB888, SIXEL_PIXELFORMAT_PAL8, + SIXEL_PIXELFORMAT_G8, SIXEL_PIXELFORMAT_G1) + except ImportError: + raise ImportError("Display in Terminal requires Pillow, libsixel " + "and a libsixel compatible terminal. " + "Please read info at https://github.com/saitoha/libsixel " + "and install with pip install Pillow libsixel-python") + + s = BytesIO() + + images = convert_to_images(obj) + widths, heights = zip(*(i.size for i in images)) + + output_width = sum(widths) + output_height = max(heights) + + output_image = PIL.Image.new('RGB', (output_width, output_height)) + + x_offset = 0 + for im in images: + output_image.paste(im, (x_offset,0)) + x_offset += im.size[0] + + try: + data = output_image.tobytes() + except NotImplementedError: + data = output_image.tostring() + output = sixel_output_new(lambda data, s: s.write(data), s) + + try: + if output_image.mode == 'RGBA': + dither = sixel_dither_new(256) + sixel_dither_initialize(dither, data, output_width, output_height, SIXEL_PIXELFORMAT_RGBA8888) + elif output_image.mode == 'RGB': + dither = sixel_dither_new(256) + sixel_dither_initialize(dither, data, output_width, output_height, SIXEL_PIXELFORMAT_RGB888) + elif output_image.mode == 'P': + palette = output_image.getpalette() + dither = sixel_dither_new(256) + sixel_dither_set_palette(dither, palette) + sixel_dither_set_pixelformat(dither, SIXEL_PIXELFORMAT_PAL8) + elif output_image.mode == 'L': + dither = sixel_dither_get(SIXEL_BUILTIN_G8) + sixel_dither_set_pixelformat(dither, SIXEL_PIXELFORMAT_G8) + elif output_image.mode == '1': + dither = sixel_dither_get(SIXEL_BUILTIN_G1) + sixel_dither_set_pixelformat(dither, SIXEL_PIXELFORMAT_G1) + else: + raise RuntimeError('unexpected output_image mode') + try: + sixel_encode(data, output_width, output_height, 1, dither, output) + print(s.getvalue().decode('ascii')) + finally: + sixel_dither_unref(dither) + finally: + sixel_output_unref(output) + + +def one_hot_from_int(int_or_list, batch_size=1): + """ Create a one-hot vector from a class index or a list of class indices. + Params: + int_or_list: int, or list of int, of the imagenet classes (between 0 and 999) + batch_size: batch size. + If int_or_list is an int create a batch of identical classes. + If int_or_list is a list, we should have `len(int_or_list) == batch_size` + Output: + array of shape (batch_size, 1000) + """ + if isinstance(int_or_list, int): + int_or_list = [int_or_list] + + if len(int_or_list) == 1 and batch_size > 1: + int_or_list = [int_or_list[0]] * batch_size + + assert batch_size == len(int_or_list) + + array = np.zeros((batch_size, NUM_CLASSES), dtype=np.float32) + for i, j in enumerate(int_or_list): + array[i, j] = 1.0 + return array + + +def one_hot_from_names(class_name_or_list, batch_size=1): + """ Create a one-hot vector from the name of an imagenet class ('tennis ball', 'daisy', ...). + We use NLTK's wordnet search to try to find the relevant synset of ImageNet and take the first one. + If we can't find it direcly, we look at the hyponyms and hypernyms of the class name. + + Params: + class_name_or_list: string containing the name of an imagenet object or a list of such strings (for a batch). + Output: + array of shape (batch_size, 1000) + """ + try: + from nltk.corpus import wordnet as wn + except ImportError: + raise ImportError("You need to install nltk to use this function") + + if not isinstance(class_name_or_list, (list, tuple)): + class_name_or_list = [class_name_or_list] + else: + batch_size = max(batch_size, len(class_name_or_list)) + + classes = [] + for class_name in class_name_or_list: + class_name = class_name.replace(" ", "_") + + original_synsets = wn.synsets(class_name) + original_synsets = list(filter(lambda s: s.pos() == 'n', original_synsets)) # keep only names + if not original_synsets: + return None + + possible_synsets = list(filter(lambda s: s.offset() in IMAGENET, original_synsets)) + if possible_synsets: + classes.append(IMAGENET[possible_synsets[0].offset()]) + else: + # try hypernyms and hyponyms + possible_synsets = sum([s.hypernyms() + s.hyponyms() for s in original_synsets], []) + possible_synsets = list(filter(lambda s: s.offset() in IMAGENET, possible_synsets)) + if possible_synsets: + classes.append(IMAGENET[possible_synsets[0].offset()]) + + return one_hot_from_int(classes, batch_size=batch_size) + + +IMAGENET = {1440764: 0, 1443537: 1, 1484850: 2, 1491361: 3, 1494475: 4, 1496331: 5, 1498041: 6, 1514668: 7, 1514859: 8, 1518878: 9, 1530575: 10, 1531178: 11, 1532829: 12, 1534433: 13, 1537544: 14, 1558993: 15, 1560419: 16, 1580077: 17, 1582220: 18, 1592084: 19, 1601694: 20, 1608432: 21, 1614925: 22, 1616318: 23, 1622779: 24, 1629819: 25, 1630670: 26, 1631663: 27, 1632458: 28, 1632777: 29, 1641577: 30, 1644373: 31, 1644900: 32, 1664065: 33, 1665541: 34, 1667114: 35, 1667778: 36, 1669191: 37, 1675722: 38, 1677366: 39, 1682714: 40, 1685808: 41, 1687978: 42, 1688243: 43, 1689811: 44, 1692333: 45, 1693334: 46, 1694178: 47, 1695060: 48, 1697457: 49, 1698640: 50, 1704323: 51, 1728572: 52, 1728920: 53, 1729322: 54, 1729977: 55, 1734418: 56, 1735189: 57, 1737021: 58, 1739381: 59, 1740131: 60, 1742172: 61, 1744401: 62, 1748264: 63, 1749939: 64, 1751748: 65, 1753488: 66, 1755581: 67, 1756291: 68, 1768244: 69, 1770081: 70, 1770393: 71, 1773157: 72, 1773549: 73, 1773797: 74, 1774384: 75, 1774750: 76, 1775062: 77, 1776313: 78, 1784675: 79, 1795545: 80, 1796340: 81, 1797886: 82, 1798484: 83, 1806143: 84, 1806567: 85, 1807496: 86, 1817953: 87, 1818515: 88, 1819313: 89, 1820546: 90, 1824575: 91, 1828970: 92, 1829413: 93, 1833805: 94, 1843065: 95, 1843383: 96, 1847000: 97, 1855032: 98, 1855672: 99, 1860187: 100, 1871265: 101, 1872401: 102, 1873310: 103, 1877812: 104, 1882714: 105, 1883070: 106, 1910747: 107, 1914609: 108, 1917289: 109, 1924916: 110, 1930112: 111, 1943899: 112, 1944390: 113, 1945685: 114, 1950731: 115, 1955084: 116, 1968897: 117, 1978287: 118, 1978455: 119, 1980166: 120, 1981276: 121, 1983481: 122, 1984695: 123, 1985128: 124, 1986214: 125, 1990800: 126, 2002556: 127, 2002724: 128, 2006656: 129, 2007558: 130, 2009229: 131, 2009912: 132, 2011460: 133, 2012849: 134, 2013706: 135, 2017213: 136, 2018207: 137, 2018795: 138, 2025239: 139, 2027492: 140, 2028035: 141, 2033041: 142, 2037110: 143, 2051845: 144, 2056570: 145, 2058221: 146, 2066245: 147, 2071294: 148, 2074367: 149, 2077923: 150, 2085620: 151, 2085782: 152, 2085936: 153, 2086079: 154, 2086240: 155, 2086646: 156, 2086910: 157, 2087046: 158, 2087394: 159, 2088094: 160, 2088238: 161, 2088364: 162, 2088466: 163, 2088632: 164, 2089078: 165, 2089867: 166, 2089973: 167, 2090379: 168, 2090622: 169, 2090721: 170, 2091032: 171, 2091134: 172, 2091244: 173, 2091467: 174, 2091635: 175, 2091831: 176, 2092002: 177, 2092339: 178, 2093256: 179, 2093428: 180, 2093647: 181, 2093754: 182, 2093859: 183, 2093991: 184, 2094114: 185, 2094258: 186, 2094433: 187, 2095314: 188, 2095570: 189, 2095889: 190, 2096051: 191, 2096177: 192, 2096294: 193, 2096437: 194, 2096585: 195, 2097047: 196, 2097130: 197, 2097209: 198, 2097298: 199, 2097474: 200, 2097658: 201, 2098105: 202, 2098286: 203, 2098413: 204, 2099267: 205, 2099429: 206, 2099601: 207, 2099712: 208, 2099849: 209, 2100236: 210, 2100583: 211, 2100735: 212, 2100877: 213, 2101006: 214, 2101388: 215, 2101556: 216, 2102040: 217, 2102177: 218, 2102318: 219, 2102480: 220, 2102973: 221, 2104029: 222, 2104365: 223, 2105056: 224, 2105162: 225, 2105251: 226, 2105412: 227, 2105505: 228, 2105641: 229, 2105855: 230, 2106030: 231, 2106166: 232, 2106382: 233, 2106550: 234, 2106662: 235, 2107142: 236, 2107312: 237, 2107574: 238, 2107683: 239, 2107908: 240, 2108000: 241, 2108089: 242, 2108422: 243, 2108551: 244, 2108915: 245, 2109047: 246, 2109525: 247, 2109961: 248, 2110063: 249, 2110185: 250, 2110341: 251, 2110627: 252, 2110806: 253, 2110958: 254, 2111129: 255, 2111277: 256, 2111500: 257, 2111889: 258, 2112018: 259, 2112137: 260, 2112350: 261, 2112706: 262, 2113023: 263, 2113186: 264, 2113624: 265, 2113712: 266, 2113799: 267, 2113978: 268, 2114367: 269, 2114548: 270, 2114712: 271, 2114855: 272, 2115641: 273, 2115913: 274, 2116738: 275, 2117135: 276, 2119022: 277, 2119789: 278, 2120079: 279, 2120505: 280, 2123045: 281, 2123159: 282, 2123394: 283, 2123597: 284, 2124075: 285, 2125311: 286, 2127052: 287, 2128385: 288, 2128757: 289, 2128925: 290, 2129165: 291, 2129604: 292, 2130308: 293, 2132136: 294, 2133161: 295, 2134084: 296, 2134418: 297, 2137549: 298, 2138441: 299, 2165105: 300, 2165456: 301, 2167151: 302, 2168699: 303, 2169497: 304, 2172182: 305, 2174001: 306, 2177972: 307, 2190166: 308, 2206856: 309, 2219486: 310, 2226429: 311, 2229544: 312, 2231487: 313, 2233338: 314, 2236044: 315, 2256656: 316, 2259212: 317, 2264363: 318, 2268443: 319, 2268853: 320, 2276258: 321, 2277742: 322, 2279972: 323, 2280649: 324, 2281406: 325, 2281787: 326, 2317335: 327, 2319095: 328, 2321529: 329, 2325366: 330, 2326432: 331, 2328150: 332, 2342885: 333, 2346627: 334, 2356798: 335, 2361337: 336, 2363005: 337, 2364673: 338, 2389026: 339, 2391049: 340, 2395406: 341, 2396427: 342, 2397096: 343, 2398521: 344, 2403003: 345, 2408429: 346, 2410509: 347, 2412080: 348, 2415577: 349, 2417914: 350, 2422106: 351, 2422699: 352, 2423022: 353, 2437312: 354, 2437616: 355, 2441942: 356, 2442845: 357, 2443114: 358, 2443484: 359, 2444819: 360, 2445715: 361, 2447366: 362, 2454379: 363, 2457408: 364, 2480495: 365, 2480855: 366, 2481823: 367, 2483362: 368, 2483708: 369, 2484975: 370, 2486261: 371, 2486410: 372, 2487347: 373, 2488291: 374, 2488702: 375, 2489166: 376, 2490219: 377, 2492035: 378, 2492660: 379, 2493509: 380, 2493793: 381, 2494079: 382, 2497673: 383, 2500267: 384, 2504013: 385, 2504458: 386, 2509815: 387, 2510455: 388, 2514041: 389, 2526121: 390, 2536864: 391, 2606052: 392, 2607072: 393, 2640242: 394, 2641379: 395, 2643566: 396, 2655020: 397, 2666196: 398, 2667093: 399, 2669723: 400, 2672831: 401, 2676566: 402, 2687172: 403, 2690373: 404, 2692877: 405, 2699494: 406, 2701002: 407, 2704792: 408, 2708093: 409, 2727426: 410, 2730930: 411, 2747177: 412, 2749479: 413, 2769748: 414, 2776631: 415, 2777292: 416, 2782093: 417, 2783161: 418, 2786058: 419, 2787622: 420, 2788148: 421, 2790996: 422, 2791124: 423, 2791270: 424, 2793495: 425, 2794156: 426, 2795169: 427, 2797295: 428, 2799071: 429, 2802426: 430, 2804414: 431, 2804610: 432, 2807133: 433, 2808304: 434, 2808440: 435, 2814533: 436, 2814860: 437, 2815834: 438, 2817516: 439, 2823428: 440, 2823750: 441, 2825657: 442, 2834397: 443, 2835271: 444, 2837789: 445, 2840245: 446, 2841315: 447, 2843684: 448, 2859443: 449, 2860847: 450, 2865351: 451, 2869837: 452, 2870880: 453, 2871525: 454, 2877765: 455, 2879718: 456, 2883205: 457, 2892201: 458, 2892767: 459, 2894605: 460, 2895154: 461, 2906734: 462, 2909870: 463, 2910353: 464, 2916936: 465, 2917067: 466, 2927161: 467, 2930766: 468, 2939185: 469, 2948072: 470, 2950826: 471, 2951358: 472, 2951585: 473, 2963159: 474, 2965783: 475, 2966193: 476, 2966687: 477, 2971356: 478, 2974003: 479, 2977058: 480, 2978881: 481, 2979186: 482, 2980441: 483, 2981792: 484, 2988304: 485, 2992211: 486, 2992529: 487, 2999410: 488, 3000134: 489, 3000247: 490, 3000684: 491, 3014705: 492, 3016953: 493, 3017168: 494, 3018349: 495, 3026506: 496, 3028079: 497, 3032252: 498, 3041632: 499, 3042490: 500, 3045698: 501, 3047690: 502, 3062245: 503, 3063599: 504, 3063689: 505, 3065424: 506, 3075370: 507, 3085013: 508, 3089624: 509, 3095699: 510, 3100240: 511, 3109150: 512, 3110669: 513, 3124043: 514, 3124170: 515, 3125729: 516, 3126707: 517, 3127747: 518, 3127925: 519, 3131574: 520, 3133878: 521, 3134739: 522, 3141823: 523, 3146219: 524, 3160309: 525, 3179701: 526, 3180011: 527, 3187595: 528, 3188531: 529, 3196217: 530, 3197337: 531, 3201208: 532, 3207743: 533, 3207941: 534, 3208938: 535, 3216828: 536, 3218198: 537, 3220513: 538, 3223299: 539, 3240683: 540, 3249569: 541, 3250847: 542, 3255030: 543, 3259280: 544, 3271574: 545, 3272010: 546, 3272562: 547, 3290653: 548, 3291819: 549, 3297495: 550, 3314780: 551, 3325584: 552, 3337140: 553, 3344393: 554, 3345487: 555, 3347037: 556, 3355925: 557, 3372029: 558, 3376595: 559, 3379051: 560, 3384352: 561, 3388043: 562, 3388183: 563, 3388549: 564, 3393912: 565, 3394916: 566, 3400231: 567, 3404251: 568, 3417042: 569, 3424325: 570, 3425413: 571, 3443371: 572, 3444034: 573, 3445777: 574, 3445924: 575, 3447447: 576, 3447721: 577, 3450230: 578, 3452741: 579, 3457902: 580, 3459775: 581, 3461385: 582, 3467068: 583, 3476684: 584, 3476991: 585, 3478589: 586, 3481172: 587, 3482405: 588, 3483316: 589, 3485407: 590, 3485794: 591, 3492542: 592, 3494278: 593, 3495258: 594, 3496892: 595, 3498962: 596, 3527444: 597, 3529860: 598, 3530642: 599, 3532672: 600, 3534580: 601, 3535780: 602, 3538406: 603, 3544143: 604, 3584254: 605, 3584829: 606, 3590841: 607, 3594734: 608, 3594945: 609, 3595614: 610, 3598930: 611, 3599486: 612, 3602883: 613, 3617480: 614, 3623198: 615, 3627232: 616, 3630383: 617, 3633091: 618, 3637318: 619, 3642806: 620, 3649909: 621, 3657121: 622, 3658185: 623, 3661043: 624, 3662601: 625, 3666591: 626, 3670208: 627, 3673027: 628, 3676483: 629, 3680355: 630, 3690938: 631, 3691459: 632, 3692522: 633, 3697007: 634, 3706229: 635, 3709823: 636, 3710193: 637, 3710637: 638, 3710721: 639, 3717622: 640, 3720891: 641, 3721384: 642, 3724870: 643, 3729826: 644, 3733131: 645, 3733281: 646, 3733805: 647, 3742115: 648, 3743016: 649, 3759954: 650, 3761084: 651, 3763968: 652, 3764736: 653, 3769881: 654, 3770439: 655, 3770679: 656, 3773504: 657, 3775071: 658, 3775546: 659, 3776460: 660, 3777568: 661, 3777754: 662, 3781244: 663, 3782006: 664, 3785016: 665, 3786901: 666, 3787032: 667, 3788195: 668, 3788365: 669, 3791053: 670, 3792782: 671, 3792972: 672, 3793489: 673, 3794056: 674, 3796401: 675, 3803284: 676, 3804744: 677, 3814639: 678, 3814906: 679, 3825788: 680, 3832673: 681, 3837869: 682, 3838899: 683, 3840681: 684, 3841143: 685, 3843555: 686, 3854065: 687, 3857828: 688, 3866082: 689, 3868242: 690, 3868863: 691, 3871628: 692, 3873416: 693, 3874293: 694, 3874599: 695, 3876231: 696, 3877472: 697, 3877845: 698, 3884397: 699, 3887697: 700, 3888257: 701, 3888605: 702, 3891251: 703, 3891332: 704, 3895866: 705, 3899768: 706, 3902125: 707, 3903868: 708, 3908618: 709, 3908714: 710, 3916031: 711, 3920288: 712, 3924679: 713, 3929660: 714, 3929855: 715, 3930313: 716, 3930630: 717, 3933933: 718, 3935335: 719, 3937543: 720, 3938244: 721, 3942813: 722, 3944341: 723, 3947888: 724, 3950228: 725, 3954731: 726, 3956157: 727, 3958227: 728, 3961711: 729, 3967562: 730, 3970156: 731, 3976467: 732, 3976657: 733, 3977966: 734, 3980874: 735, 3982430: 736, 3983396: 737, 3991062: 738, 3992509: 739, 3995372: 740, 3998194: 741, 4004767: 742, 4005630: 743, 4008634: 744, 4009552: 745, 4019541: 746, 4023962: 747, 4026417: 748, 4033901: 749, 4033995: 750, 4037443: 751, 4039381: 752, 4040759: 753, 4041544: 754, 4044716: 755, 4049303: 756, 4065272: 757, 4067472: 758, 4069434: 759, 4070727: 760, 4074963: 761, 4081281: 762, 4086273: 763, 4090263: 764, 4099969: 765, 4111531: 766, 4116512: 767, 4118538: 768, 4118776: 769, 4120489: 770, 4125021: 771, 4127249: 772, 4131690: 773, 4133789: 774, 4136333: 775, 4141076: 776, 4141327: 777, 4141975: 778, 4146614: 779, 4147183: 780, 4149813: 781, 4152593: 782, 4153751: 783, 4154565: 784, 4162706: 785, 4179913: 786, 4192698: 787, 4200800: 788, 4201297: 789, 4204238: 790, 4204347: 791, 4208210: 792, 4209133: 793, 4209239: 794, 4228054: 795, 4229816: 796, 4235860: 797, 4238763: 798, 4239074: 799, 4243546: 800, 4251144: 801, 4252077: 802, 4252225: 803, 4254120: 804, 4254680: 805, 4254777: 806, 4258138: 807, 4259630: 808, 4263257: 809, 4264628: 810, 4265275: 811, 4266014: 812, 4270147: 813, 4273569: 814, 4275548: 815, 4277352: 816, 4285008: 817, 4286575: 818, 4296562: 819, 4310018: 820, 4311004: 821, 4311174: 822, 4317175: 823, 4325704: 824, 4326547: 825, 4328186: 826, 4330267: 827, 4332243: 828, 4335435: 829, 4336792: 830, 4344873: 831, 4346328: 832, 4347754: 833, 4350905: 834, 4355338: 835, 4355933: 836, 4356056: 837, 4357314: 838, 4366367: 839, 4367480: 840, 4370456: 841, 4371430: 842, 4371774: 843, 4372370: 844, 4376876: 845, 4380533: 846, 4389033: 847, 4392985: 848, 4398044: 849, 4399382: 850, 4404412: 851, 4409515: 852, 4417672: 853, 4418357: 854, 4423845: 855, 4428191: 856, 4429376: 857, 4435653: 858, 4442312: 859, 4443257: 860, 4447861: 861, 4456115: 862, 4458633: 863, 4461696: 864, 4462240: 865, 4465501: 866, 4467665: 867, 4476259: 868, 4479046: 869, 4482393: 870, 4483307: 871, 4485082: 872, 4486054: 873, 4487081: 874, 4487394: 875, 4493381: 876, 4501370: 877, 4505470: 878, 4507155: 879, 4509417: 880, 4515003: 881, 4517823: 882, 4522168: 883, 4523525: 884, 4525038: 885, 4525305: 886, 4532106: 887, 4532670: 888, 4536866: 889, 4540053: 890, 4542943: 891, 4548280: 892, 4548362: 893, 4550184: 894, 4552348: 895, 4553703: 896, 4554684: 897, 4557648: 898, 4560804: 899, 4562935: 900, 4579145: 901, 4579432: 902, 4584207: 903, 4589890: 904, 4590129: 905, 4591157: 906, 4591713: 907, 4592741: 908, 4596742: 909, 4597913: 910, 4599235: 911, 4604644: 912, 4606251: 913, 4612504: 914, 4613696: 915, 6359193: 916, 6596364: 917, 6785654: 918, 6794110: 919, 6874185: 920, 7248320: 921, 7565083: 922, 7579787: 923, 7583066: 924, 7584110: 925, 7590611: 926, 7613480: 927, 7614500: 928, 7615774: 929, 7684084: 930, 7693725: 931, 7695742: 932, 7697313: 933, 7697537: 934, 7711569: 935, 7714571: 936, 7714990: 937, 7715103: 938, 7716358: 939, 7716906: 940, 7717410: 941, 7717556: 942, 7718472: 943, 7718747: 944, 7720875: 945, 7730033: 946, 7734744: 947, 7742313: 948, 7745940: 949, 7747607: 950, 7749582: 951, 7753113: 952, 7753275: 953, 7753592: 954, 7754684: 955, 7760859: 956, 7768694: 957, 7802026: 958, 7831146: 959, 7836838: 960, 7860988: 961, 7871810: 962, 7873807: 963, 7875152: 964, 7880968: 965, 7892512: 966, 7920052: 967, 7930864: 968, 7932039: 969, 9193705: 970, 9229709: 971, 9246464: 972, 9256479: 973, 9288635: 974, 9332890: 975, 9399592: 976, 9421951: 977, 9428293: 978, 9468604: 979, 9472597: 980, 9835506: 981, 10148035: 982, 10565667: 983, 11879895: 984, 11939491: 985, 12057211: 986, 12144580: 987, 12267677: 988, 12620546: 989, 12768682: 990, 12985857: 991, 12998815: 992, 13037406: 993, 13040303: 994, 13044778: 995, 13052670: 996, 13054560: 997, 13133613: 998, 15075141: 999} diff --git a/models/biggan/pytorch_biggan/requirements.txt b/models/biggan/pytorch_biggan/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..f37f11cc540bb1f0f777d9e08a23b9773a8db7c0 --- /dev/null +++ b/models/biggan/pytorch_biggan/requirements.txt @@ -0,0 +1,8 @@ +# PyTorch +torch>=0.4.1 +# progress bars in model download and training scripts +tqdm +# Accessing files from S3 directly. +boto3 +# Used for downloading models over HTTP +requests \ No newline at end of file diff --git a/models/biggan/pytorch_biggan/scripts/convert_tf_hub_models.sh b/models/biggan/pytorch_biggan/scripts/convert_tf_hub_models.sh new file mode 100644 index 0000000000000000000000000000000000000000..caed81a1e9698014ac61e8baa3d98d256cb3b4dd --- /dev/null +++ b/models/biggan/pytorch_biggan/scripts/convert_tf_hub_models.sh @@ -0,0 +1,21 @@ +# Copyright (c) 2019-present, Thomas Wolf, Huggingface Inc. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. +# + +set -e +set -x + +models="128 256 512" + +mkdir -p models/model_128 +mkdir -p models/model_256 +mkdir -p models/model_512 + +# Convert TF Hub models. +for model in $models +do + pytorch_pretrained_biggan --model_type $model --tf_model_path models/model_$model --pt_save_path models/model_$model +done diff --git a/models/biggan/pytorch_biggan/scripts/download_tf_hub_models.sh b/models/biggan/pytorch_biggan/scripts/download_tf_hub_models.sh new file mode 100644 index 0000000000000000000000000000000000000000..57655fbd4b77791f03d72b3dfeb3bbb89ccc2fdc --- /dev/null +++ b/models/biggan/pytorch_biggan/scripts/download_tf_hub_models.sh @@ -0,0 +1,21 @@ +# Copyright (c) 2019-present, Thomas Wolf, Huggingface Inc. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. +# + +set -e +set -x + +models="128 256 512" + +mkdir -p models/model_128 +mkdir -p models/model_256 +mkdir -p models/model_512 + +# Download TF Hub models. +for model in $models +do + curl -L "https://tfhub.dev/deepmind/biggan-deep-$model/1?tf-hub-format=compressed" | tar -zxvC models/model_$model +done diff --git a/models/biggan/pytorch_biggan/setup.py b/models/biggan/pytorch_biggan/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..a34318b6b66f1ca7b15342dea3c23eb904974d6d --- /dev/null +++ b/models/biggan/pytorch_biggan/setup.py @@ -0,0 +1,69 @@ +""" +Simple check list from AllenNLP repo: https://github.com/allenai/allennlp/blob/master/setup.py + +To create the package for pypi. + +1. Change the version in __init__.py and setup.py. + +2. Commit these changes with the message: "Release: VERSION" + +3. Add a tag in git to mark the release: "git tag VERSION -m'Adds tag VERSION for pypi' " + Push the tag to git: git push --tags origin master + +4. Build both the sources and the wheel. Do not change anything in setup.py between + creating the wheel and the source distribution (obviously). + + For the wheel, run: "python setup.py bdist_wheel" in the top level allennlp directory. + (this will build a wheel for the python version you use to build it - make sure you use python 3.x). + + For the sources, run: "python setup.py sdist" + You should now have a /dist directory with both .whl and .tar.gz source versions of allennlp. + +5. Check that everything looks correct by uploading the package to the pypi test server: + + twine upload dist/* -r pypitest + (pypi suggest using twine as other methods upload files via plaintext.) + + Check that you can install it in a virtualenv by running: + pip install -i https://testpypi.python.org/pypi allennlp + +6. Upload the final version to actual pypi: + twine upload dist/* -r pypi + +7. Copy the release notes from RELEASE.md to the tag in github once everything is looking hunky-dory. + +""" +from io import open +from setuptools import find_packages, setup + +setup( + name="pytorch_pretrained_biggan", + version="0.1.0", + author="Thomas Wolf", + author_email="thomas@huggingface.co", + description="PyTorch version of DeepMind's BigGAN model with pre-trained models", + long_description=open("README.md", "r", encoding='utf-8').read(), + long_description_content_type="text/markdown", + keywords='BIGGAN GAN deep learning google deepmind', + license='Apache', + url="https://github.com/huggingface/pytorch-pretrained-BigGAN", + packages=find_packages(exclude=["*.tests", "*.tests.*", + "tests.*", "tests"]), + install_requires=['torch>=0.4.1', + 'numpy', + 'boto3', + 'requests', + 'tqdm'], + tests_require=['pytest'], + entry_points={ + 'console_scripts': [ + "pytorch_pretrained_biggan=pytorch_pretrained_biggan.convert_tf_to_pytorch:main", + ] + }, + classifiers=[ + 'Intended Audience :: Science/Research', + 'License :: OSI Approved :: Apache Software License', + 'Programming Language :: Python :: 3', + 'Topic :: Scientific/Engineering :: Artificial Intelligence', + ], +) diff --git a/models/stylegan/__init__.py b/models/stylegan/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6edf9b7e860d2b45ed1ccf40223c6fac0b273ab7 --- /dev/null +++ b/models/stylegan/__init__.py @@ -0,0 +1,17 @@ +# Copyright 2020 Erik Härkönen. All rights reserved. +# This file is licensed to you under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. You may obtain a copy +# of the License at http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software distributed under +# the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS +# OF ANY KIND, either express or implied. See the License for the specific language +# governing permissions and limitations under the License. + +from pathlib import Path +import sys + +#module_path = Path(__file__).parent / 'pytorch_biggan' +#sys.path.append(str(module_path.resolve())) + +from .model import StyleGAN_G, NoiseLayer \ No newline at end of file diff --git a/models/stylegan/__pycache__/__init__.cpython-310.pyc b/models/stylegan/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ee7ce43bc225062497837e39c335e373dc149846 Binary files /dev/null and b/models/stylegan/__pycache__/__init__.cpython-310.pyc differ diff --git a/models/stylegan/__pycache__/model.cpython-310.pyc b/models/stylegan/__pycache__/model.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..325ec26523d0b566773fae339a0479d42ca6a029 Binary files /dev/null and b/models/stylegan/__pycache__/model.cpython-310.pyc differ diff --git a/models/stylegan/model.py b/models/stylegan/model.py new file mode 100644 index 0000000000000000000000000000000000000000..a230961c4d1bf0bd2d1efe7972b4baa33c5d7013 --- /dev/null +++ b/models/stylegan/model.py @@ -0,0 +1,456 @@ +# Copyright 2020 Erik Härkönen. All rights reserved. +# This file is licensed to you under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. You may obtain a copy +# of the License at http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software distributed under +# the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS +# OF ANY KIND, either express or implied. See the License for the specific language +# governing permissions and limitations under the License. + +import torch +import torch.nn as nn +import torch.nn.functional as F + +from collections import OrderedDict +from pathlib import Path +import requests +import pickle +import sys + +import numpy as np + +# Reimplementation of StyleGAN in PyTorch +# Source: https://github.com/lernapparat/lernapparat/blob/master/style_gan/pytorch_style_gan.ipynb + +class MyLinear(nn.Module): + """Linear layer with equalized learning rate and custom learning rate multiplier.""" + def __init__(self, input_size, output_size, gain=2**(0.5), use_wscale=False, lrmul=1, bias=True): + super().__init__() + he_std = gain * input_size**(-0.5) # He init + # Equalized learning rate and custom learning rate multiplier. + if use_wscale: + init_std = 1.0 / lrmul + self.w_mul = he_std * lrmul + else: + init_std = he_std / lrmul + self.w_mul = lrmul + self.weight = torch.nn.Parameter(torch.randn(output_size, input_size) * init_std) + if bias: + self.bias = torch.nn.Parameter(torch.zeros(output_size)) + self.b_mul = lrmul + else: + self.bias = None + + def forward(self, x): + bias = self.bias + if bias is not None: + bias = bias * self.b_mul + return F.linear(x, self.weight * self.w_mul, bias) + +class MyConv2d(nn.Module): + """Conv layer with equalized learning rate and custom learning rate multiplier.""" + def __init__(self, input_channels, output_channels, kernel_size, gain=2**(0.5), use_wscale=False, lrmul=1, bias=True, + intermediate=None, upscale=False): + super().__init__() + if upscale: + self.upscale = Upscale2d() + else: + self.upscale = None + he_std = gain * (input_channels * kernel_size ** 2) ** (-0.5) # He init + self.kernel_size = kernel_size + if use_wscale: + init_std = 1.0 / lrmul + self.w_mul = he_std * lrmul + else: + init_std = he_std / lrmul + self.w_mul = lrmul + self.weight = torch.nn.Parameter(torch.randn(output_channels, input_channels, kernel_size, kernel_size) * init_std) + if bias: + self.bias = torch.nn.Parameter(torch.zeros(output_channels)) + self.b_mul = lrmul + else: + self.bias = None + self.intermediate = intermediate + + def forward(self, x): + bias = self.bias + if bias is not None: + bias = bias * self.b_mul + + have_convolution = False + if self.upscale is not None and min(x.shape[2:]) * 2 >= 128: + # this is the fused upscale + conv from StyleGAN, sadly this seems incompatible with the non-fused way + # this really needs to be cleaned up and go into the conv... + w = self.weight * self.w_mul + w = w.permute(1, 0, 2, 3) + # probably applying a conv on w would be more efficient. also this quadruples the weight (average)?! + w = F.pad(w, (1,1,1,1)) + w = w[:, :, 1:, 1:]+ w[:, :, :-1, 1:] + w[:, :, 1:, :-1] + w[:, :, :-1, :-1] + x = F.conv_transpose2d(x, w, stride=2, padding=(w.size(-1)-1)//2) + have_convolution = True + elif self.upscale is not None: + x = self.upscale(x) + + if not have_convolution and self.intermediate is None: + return F.conv2d(x, self.weight * self.w_mul, bias, padding=self.kernel_size//2) + elif not have_convolution: + x = F.conv2d(x, self.weight * self.w_mul, None, padding=self.kernel_size//2) + + if self.intermediate is not None: + x = self.intermediate(x) + if bias is not None: + x = x + bias.view(1, -1, 1, 1) + return x + +class NoiseLayer(nn.Module): + """adds noise. noise is per pixel (constant over channels) with per-channel weight""" + def __init__(self, channels): + super().__init__() + self.weight = nn.Parameter(torch.zeros(channels)) + self.noise = None + + def forward(self, x, noise=None): + if noise is None and self.noise is None: + noise = torch.randn(x.size(0), 1, x.size(2), x.size(3), device=x.device, dtype=x.dtype) + elif noise is None: + # here is a little trick: if you get all the noiselayers and set each + # modules .noise attribute, you can have pre-defined noise. + # Very useful for analysis + noise = self.noise + x = x + self.weight.view(1, -1, 1, 1) * noise + return x + +class StyleMod(nn.Module): + def __init__(self, latent_size, channels, use_wscale): + super(StyleMod, self).__init__() + self.lin = MyLinear(latent_size, + channels * 2, + gain=1.0, use_wscale=use_wscale) + + def forward(self, x, latent): + style = self.lin(latent) # style => [batch_size, n_channels*2] + shape = [-1, 2, x.size(1)] + (x.dim() - 2) * [1] + style = style.view(shape) # [batch_size, 2, n_channels, ...] + x = x * (style[:, 0] + 1.) + style[:, 1] + return x + +class PixelNormLayer(nn.Module): + def __init__(self, epsilon=1e-8): + super().__init__() + self.epsilon = epsilon + def forward(self, x): + return x * torch.rsqrt(torch.mean(x**2, dim=1, keepdim=True) + self.epsilon) + +class BlurLayer(nn.Module): + def __init__(self, kernel=[1, 2, 1], normalize=True, flip=False, stride=1): + super(BlurLayer, self).__init__() + kernel=[1, 2, 1] + kernel = torch.tensor(kernel, dtype=torch.float32) + kernel = kernel[:, None] * kernel[None, :] + kernel = kernel[None, None] + if normalize: + kernel = kernel / kernel.sum() + if flip: + kernel = kernel[:, :, ::-1, ::-1] + self.register_buffer('kernel', kernel) + self.stride = stride + + def forward(self, x): + # expand kernel channels + kernel = self.kernel.expand(x.size(1), -1, -1, -1) + x = F.conv2d( + x, + kernel, + stride=self.stride, + padding=int((self.kernel.size(2)-1)/2), + groups=x.size(1) + ) + return x + +def upscale2d(x, factor=2, gain=1): + assert x.dim() == 4 + if gain != 1: + x = x * gain + if factor != 1: + shape = x.shape + x = x.view(shape[0], shape[1], shape[2], 1, shape[3], 1).expand(-1, -1, -1, factor, -1, factor) + x = x.contiguous().view(shape[0], shape[1], factor * shape[2], factor * shape[3]) + return x + +class Upscale2d(nn.Module): + def __init__(self, factor=2, gain=1): + super().__init__() + assert isinstance(factor, int) and factor >= 1 + self.gain = gain + self.factor = factor + def forward(self, x): + return upscale2d(x, factor=self.factor, gain=self.gain) + +class G_mapping(nn.Sequential): + def __init__(self, nonlinearity='lrelu', use_wscale=True): + act, gain = {'relu': (torch.relu, np.sqrt(2)), + 'lrelu': (nn.LeakyReLU(negative_slope=0.2), np.sqrt(2))}[nonlinearity] + layers = [ + ('pixel_norm', PixelNormLayer()), + ('dense0', MyLinear(512, 512, gain=gain, lrmul=0.01, use_wscale=use_wscale)), + ('dense0_act', act), + ('dense1', MyLinear(512, 512, gain=gain, lrmul=0.01, use_wscale=use_wscale)), + ('dense1_act', act), + ('dense2', MyLinear(512, 512, gain=gain, lrmul=0.01, use_wscale=use_wscale)), + ('dense2_act', act), + ('dense3', MyLinear(512, 512, gain=gain, lrmul=0.01, use_wscale=use_wscale)), + ('dense3_act', act), + ('dense4', MyLinear(512, 512, gain=gain, lrmul=0.01, use_wscale=use_wscale)), + ('dense4_act', act), + ('dense5', MyLinear(512, 512, gain=gain, lrmul=0.01, use_wscale=use_wscale)), + ('dense5_act', act), + ('dense6', MyLinear(512, 512, gain=gain, lrmul=0.01, use_wscale=use_wscale)), + ('dense6_act', act), + ('dense7', MyLinear(512, 512, gain=gain, lrmul=0.01, use_wscale=use_wscale)), + ('dense7_act', act) + ] + super().__init__(OrderedDict(layers)) + + def forward(self, x): + return super().forward(x) + +class Truncation(nn.Module): + def __init__(self, avg_latent, max_layer=8, threshold=0.7): + super().__init__() + self.max_layer = max_layer + self.threshold = threshold + self.register_buffer('avg_latent', avg_latent) + def forward(self, x): + assert x.dim() == 3 + interp = torch.lerp(self.avg_latent, x, self.threshold) + do_trunc = (torch.arange(x.size(1)) < self.max_layer).view(1, -1, 1) + return torch.where(do_trunc, interp, x) + +class LayerEpilogue(nn.Module): + """Things to do at the end of each layer.""" + def __init__(self, channels, dlatent_size, use_wscale, use_noise, use_pixel_norm, use_instance_norm, use_styles, activation_layer): + super().__init__() + layers = [] + if use_noise: + layers.append(('noise', NoiseLayer(channels))) + layers.append(('activation', activation_layer)) + if use_pixel_norm: + layers.append(('pixel_norm', PixelNorm())) + if use_instance_norm: + layers.append(('instance_norm', nn.InstanceNorm2d(channels))) + self.top_epi = nn.Sequential(OrderedDict(layers)) + if use_styles: + self.style_mod = StyleMod(dlatent_size, channels, use_wscale=use_wscale) + else: + self.style_mod = None + def forward(self, x, dlatents_in_slice=None): + x = self.top_epi(x) + if self.style_mod is not None: + x = self.style_mod(x, dlatents_in_slice) + else: + assert dlatents_in_slice is None + return x + + +class InputBlock(nn.Module): + def __init__(self, nf, dlatent_size, const_input_layer, gain, use_wscale, use_noise, use_pixel_norm, use_instance_norm, use_styles, activation_layer): + super().__init__() + self.const_input_layer = const_input_layer + self.nf = nf + if self.const_input_layer: + # called 'const' in tf + self.const = nn.Parameter(torch.ones(1, nf, 4, 4)) + self.bias = nn.Parameter(torch.ones(nf)) + else: + self.dense = MyLinear(dlatent_size, nf*16, gain=gain/4, use_wscale=use_wscale) # tweak gain to match the official implementation of Progressing GAN + self.epi1 = LayerEpilogue(nf, dlatent_size, use_wscale, use_noise, use_pixel_norm, use_instance_norm, use_styles, activation_layer) + self.conv = MyConv2d(nf, nf, 3, gain=gain, use_wscale=use_wscale) + self.epi2 = LayerEpilogue(nf, dlatent_size, use_wscale, use_noise, use_pixel_norm, use_instance_norm, use_styles, activation_layer) + + def forward(self, dlatents_in_range): + batch_size = dlatents_in_range.size(0) + if self.const_input_layer: + x = self.const.expand(batch_size, -1, -1, -1) + x = x + self.bias.view(1, -1, 1, 1) + else: + x = self.dense(dlatents_in_range[:, 0]).view(batch_size, self.nf, 4, 4) + x = self.epi1(x, dlatents_in_range[:, 0]) + x = self.conv(x) + x = self.epi2(x, dlatents_in_range[:, 1]) + return x + + +class GSynthesisBlock(nn.Module): + def __init__(self, in_channels, out_channels, blur_filter, dlatent_size, gain, use_wscale, use_noise, use_pixel_norm, use_instance_norm, use_styles, activation_layer): + # 2**res x 2**res # res = 3..resolution_log2 + super().__init__() + if blur_filter: + blur = BlurLayer(blur_filter) + else: + blur = None + self.conv0_up = MyConv2d(in_channels, out_channels, kernel_size=3, gain=gain, use_wscale=use_wscale, + intermediate=blur, upscale=True) + self.epi1 = LayerEpilogue(out_channels, dlatent_size, use_wscale, use_noise, use_pixel_norm, use_instance_norm, use_styles, activation_layer) + self.conv1 = MyConv2d(out_channels, out_channels, kernel_size=3, gain=gain, use_wscale=use_wscale) + self.epi2 = LayerEpilogue(out_channels, dlatent_size, use_wscale, use_noise, use_pixel_norm, use_instance_norm, use_styles, activation_layer) + + def forward(self, x, dlatents_in_range): + x = self.conv0_up(x) + x = self.epi1(x, dlatents_in_range[:, 0]) + x = self.conv1(x) + x = self.epi2(x, dlatents_in_range[:, 1]) + return x + +class G_synthesis(nn.Module): + def __init__(self, + dlatent_size = 512, # Disentangled latent (W) dimensionality. + num_channels = 3, # Number of output color channels. + resolution = 1024, # Output resolution. + fmap_base = 8192, # Overall multiplier for the number of feature maps. + fmap_decay = 1.0, # log2 feature map reduction when doubling the resolution. + fmap_max = 512, # Maximum number of feature maps in any layer. + use_styles = True, # Enable style inputs? + const_input_layer = True, # First layer is a learned constant? + use_noise = True, # Enable noise inputs? + randomize_noise = True, # True = randomize noise inputs every time (non-deterministic), False = read noise inputs from variables. + nonlinearity = 'lrelu', # Activation function: 'relu', 'lrelu' + use_wscale = True, # Enable equalized learning rate? + use_pixel_norm = False, # Enable pixelwise feature vector normalization? + use_instance_norm = True, # Enable instance normalization? + dtype = torch.float32, # Data type to use for activations and outputs. + blur_filter = [1,2,1], # Low-pass filter to apply when resampling activations. None = no filtering. + ): + + super().__init__() + def nf(stage): + return min(int(fmap_base / (2.0 ** (stage * fmap_decay))), fmap_max) + self.dlatent_size = dlatent_size + resolution_log2 = int(np.log2(resolution)) + assert resolution == 2**resolution_log2 and resolution >= 4 + + act, gain = {'relu': (torch.relu, np.sqrt(2)), + 'lrelu': (nn.LeakyReLU(negative_slope=0.2), np.sqrt(2))}[nonlinearity] + num_layers = resolution_log2 * 2 - 2 + num_styles = num_layers if use_styles else 1 + torgbs = [] + blocks = [] + for res in range(2, resolution_log2 + 1): + channels = nf(res-1) + name = '{s}x{s}'.format(s=2**res) + if res == 2: + blocks.append((name, + InputBlock(channels, dlatent_size, const_input_layer, gain, use_wscale, + use_noise, use_pixel_norm, use_instance_norm, use_styles, act))) + + else: + blocks.append((name, + GSynthesisBlock(last_channels, channels, blur_filter, dlatent_size, gain, use_wscale, use_noise, use_pixel_norm, use_instance_norm, use_styles, act))) + last_channels = channels + self.torgb = MyConv2d(channels, num_channels, 1, gain=1, use_wscale=use_wscale) + self.blocks = nn.ModuleDict(OrderedDict(blocks)) + + def forward(self, dlatents_in): + # Input: Disentangled latents (W) [minibatch, num_layers, dlatent_size]. + # lod_in = tf.cast(tf.get_variable('lod', initializer=np.float32(0), trainable=False), dtype) + batch_size = dlatents_in.size(0) + for i, m in enumerate(self.blocks.values()): + if i == 0: + x = m(dlatents_in[:, 2*i:2*i+2]) + else: + x = m(x, dlatents_in[:, 2*i:2*i+2]) + rgb = self.torgb(x) + return rgb + + +class StyleGAN_G(nn.Sequential): + def __init__(self, resolution, truncation=1.0): + self.resolution = resolution + self.layers = OrderedDict([ + ('g_mapping', G_mapping()), + #('truncation', Truncation(avg_latent)), + ('g_synthesis', G_synthesis(resolution=resolution)), + ]) + super().__init__(self.layers) + + def forward(self, x, latent_is_w=False): + if isinstance(x, list): + assert len(x) == 18, 'Must provide 1 or 18 latents' + if not latent_is_w: + x = [self.layers['g_mapping'].forward(l) for l in x] + x = torch.stack(x, dim=1) + else: + if not latent_is_w: + x = self.layers['g_mapping'].forward(x) + x = x.unsqueeze(1).expand(-1, 18, -1) + + x = self.layers['g_synthesis'].forward(x) + + return x + + # From: https://github.com/lernapparat/lernapparat/releases/download/v2019-02-01/ + def load_weights(self, checkpoint): + self.load_state_dict(torch.load(checkpoint)) + + def export_from_tf(self, pickle_path): + module_path = Path(__file__).parent / 'stylegan_tf' + sys.path.append(str(module_path.resolve())) + + import dnnlib, dnnlib.tflib, pickle, torch, collections + dnnlib.tflib.init_tf() + + weights = pickle.load(open(pickle_path,'rb')) + weights_pt = [collections.OrderedDict([(k, torch.from_numpy(v.value().eval())) for k,v in w.trainables.items()]) for w in weights] + #torch.save(weights_pt, pytorch_name) + + # then on the PyTorch side run + state_G, state_D, state_Gs = weights_pt #torch.load('./karras2019stylegan-ffhq-1024x1024.pt') + def key_translate(k): + k = k.lower().split('/') + if k[0] == 'g_synthesis': + if not k[1].startswith('torgb'): + k.insert(1, 'blocks') + k = '.'.join(k) + k = (k.replace('const.const','const').replace('const.bias','bias').replace('const.stylemod','epi1.style_mod.lin') + .replace('const.noise.weight','epi1.top_epi.noise.weight') + .replace('conv.noise.weight','epi2.top_epi.noise.weight') + .replace('conv.stylemod','epi2.style_mod.lin') + .replace('conv0_up.noise.weight', 'epi1.top_epi.noise.weight') + .replace('conv0_up.stylemod','epi1.style_mod.lin') + .replace('conv1.noise.weight', 'epi2.top_epi.noise.weight') + .replace('conv1.stylemod','epi2.style_mod.lin') + .replace('torgb_lod0','torgb')) + else: + k = '.'.join(k) + return k + + def weight_translate(k, w): + k = key_translate(k) + if k.endswith('.weight'): + if w.dim() == 2: + w = w.t() + elif w.dim() == 1: + pass + else: + assert w.dim() == 4 + w = w.permute(3, 2, 0, 1) + return w + + # we delete the useless torgb filters + param_dict = {key_translate(k) : weight_translate(k, v) for k,v in state_Gs.items() if 'torgb_lod' not in key_translate(k)} + if 1: + sd_shapes = {k : v.shape for k,v in self.state_dict().items()} + param_shapes = {k : v.shape for k,v in param_dict.items() } + + for k in list(sd_shapes)+list(param_shapes): + pds = param_shapes.get(k) + sds = sd_shapes.get(k) + if pds is None: + print ("sd only", k, sds) + elif sds is None: + print ("pd only", k, pds) + elif sds != pds: + print ("mismatch!", k, pds, sds) + + self.load_state_dict(param_dict, strict=False) # needed for the blur kernels + torch.save(self.state_dict(), Path(pickle_path).with_suffix('.pt')) \ No newline at end of file diff --git a/models/stylegan/stylegan_tf/LICENSE.txt b/models/stylegan/stylegan_tf/LICENSE.txt new file mode 100644 index 0000000000000000000000000000000000000000..ca56419327bbeeb8094330497024f109bd52b96d --- /dev/null +++ b/models/stylegan/stylegan_tf/LICENSE.txt @@ -0,0 +1,410 @@ +Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved. + + +Attribution-NonCommercial 4.0 International + +======================================================================= + +Creative Commons Corporation ("Creative Commons") is not a law firm and +does not provide legal services or legal advice. Distribution of +Creative Commons public licenses does not create a lawyer-client or +other relationship. Creative Commons makes its licenses and related +information available on an "as-is" basis. Creative Commons gives no +warranties regarding its licenses, any material licensed under their +terms and conditions, or any related information. Creative Commons +disclaims all liability for damages resulting from their use to the +fullest extent possible. + +Using Creative Commons Public Licenses + +Creative Commons public licenses provide a standard set of terms and +conditions that creators and other rights holders may use to share +original works of authorship and other material subject to copyright +and certain other rights specified in the public license below. The +following considerations are for informational purposes only, are not +exhaustive, and do not form part of our licenses. + + Considerations for licensors: Our public licenses are + intended for use by those authorized to give the public + permission to use material in ways otherwise restricted by + copyright and certain other rights. Our licenses are + irrevocable. Licensors should read and understand the terms + and conditions of the license they choose before applying it. + Licensors should also secure all rights necessary before + applying our licenses so that the public can reuse the + material as expected. Licensors should clearly mark any + material not subject to the license. This includes other CC- + licensed material, or material used under an exception or + limitation to copyright. More considerations for licensors: + wiki.creativecommons.org/Considerations_for_licensors + + Considerations for the public: By using one of our public + licenses, a licensor grants the public permission to use the + licensed material under specified terms and conditions. If + the licensor's permission is not necessary for any reason--for + example, because of any applicable exception or limitation to + copyright--then that use is not regulated by the license. Our + licenses grant only permissions under copyright and certain + other rights that a licensor has authority to grant. Use of + the licensed material may still be restricted for other + reasons, including because others have copyright or other + rights in the material. A licensor may make special requests, + such as asking that all changes be marked or described. + Although not required by our licenses, you are encouraged to + respect those requests where reasonable. More_considerations + for the public: + wiki.creativecommons.org/Considerations_for_licensees + +======================================================================= + +Creative Commons Attribution-NonCommercial 4.0 International Public +License + +By exercising the Licensed Rights (defined below), You accept and agree +to be bound by the terms and conditions of this Creative Commons +Attribution-NonCommercial 4.0 International Public License ("Public +License"). To the extent this Public License may be interpreted as a +contract, You are granted the Licensed Rights in consideration of Your +acceptance of these terms and conditions, and the Licensor grants You +such rights in consideration of benefits the Licensor receives from +making the Licensed Material available under these terms and +conditions. + + +Section 1 -- Definitions. + + a. Adapted Material means material subject to Copyright and Similar + Rights that is derived from or based upon the Licensed Material + and in which the Licensed Material is translated, altered, + arranged, transformed, or otherwise modified in a manner requiring + permission under the Copyright and Similar Rights held by the + Licensor. For purposes of this Public License, where the Licensed + Material is a musical work, performance, or sound recording, + Adapted Material is always produced where the Licensed Material is + synched in timed relation with a moving image. + + b. Adapter's License means the license You apply to Your Copyright + and Similar Rights in Your contributions to Adapted Material in + accordance with the terms and conditions of this Public License. + + c. Copyright and Similar Rights means copyright and/or similar rights + closely related to copyright including, without limitation, + performance, broadcast, sound recording, and Sui Generis Database + Rights, without regard to how the rights are labeled or + categorized. For purposes of this Public License, the rights + specified in Section 2(b)(1)-(2) are not Copyright and Similar + Rights. + d. Effective Technological Measures means those measures that, in the + absence of proper authority, may not be circumvented under laws + fulfilling obligations under Article 11 of the WIPO Copyright + Treaty adopted on December 20, 1996, and/or similar international + agreements. + + e. Exceptions and Limitations means fair use, fair dealing, and/or + any other exception or limitation to Copyright and Similar Rights + that applies to Your use of the Licensed Material. + + f. Licensed Material means the artistic or literary work, database, + or other material to which the Licensor applied this Public + License. + + g. Licensed Rights means the rights granted to You subject to the + terms and conditions of this Public License, which are limited to + all Copyright and Similar Rights that apply to Your use of the + Licensed Material and that the Licensor has authority to license. + + h. Licensor means the individual(s) or entity(ies) granting rights + under this Public License. + + i. NonCommercial means not primarily intended for or directed towards + commercial advantage or monetary compensation. For purposes of + this Public License, the exchange of the Licensed Material for + other material subject to Copyright and Similar Rights by digital + file-sharing or similar means is NonCommercial provided there is + no payment of monetary compensation in connection with the + exchange. + + j. Share means to provide material to the public by any means or + process that requires permission under the Licensed Rights, such + as reproduction, public display, public performance, distribution, + dissemination, communication, or importation, and to make material + available to the public including in ways that members of the + public may access the material from a place and at a time + individually chosen by them. + + k. Sui Generis Database Rights means rights other than copyright + resulting from Directive 96/9/EC of the European Parliament and of + the Council of 11 March 1996 on the legal protection of databases, + as amended and/or succeeded, as well as other essentially + equivalent rights anywhere in the world. + + l. You means the individual or entity exercising the Licensed Rights + under this Public License. Your has a corresponding meaning. + + +Section 2 -- Scope. + + a. License grant. + + 1. Subject to the terms and conditions of this Public License, + the Licensor hereby grants You a worldwide, royalty-free, + non-sublicensable, non-exclusive, irrevocable license to + exercise the Licensed Rights in the Licensed Material to: + + a. reproduce and Share the Licensed Material, in whole or + in part, for NonCommercial purposes only; and + + b. produce, reproduce, and Share Adapted Material for + NonCommercial purposes only. + + 2. Exceptions and Limitations. For the avoidance of doubt, where + Exceptions and Limitations apply to Your use, this Public + License does not apply, and You do not need to comply with + its terms and conditions. + + 3. Term. The term of this Public License is specified in Section + 6(a). + + 4. Media and formats; technical modifications allowed. The + Licensor authorizes You to exercise the Licensed Rights in + all media and formats whether now known or hereafter created, + and to make technical modifications necessary to do so. The + Licensor waives and/or agrees not to assert any right or + authority to forbid You from making technical modifications + necessary to exercise the Licensed Rights, including + technical modifications necessary to circumvent Effective + Technological Measures. For purposes of this Public License, + simply making modifications authorized by this Section 2(a) + (4) never produces Adapted Material. + + 5. Downstream recipients. + + a. Offer from the Licensor -- Licensed Material. Every + recipient of the Licensed Material automatically + receives an offer from the Licensor to exercise the + Licensed Rights under the terms and conditions of this + Public License. + + b. No downstream restrictions. You may not offer or impose + any additional or different terms or conditions on, or + apply any Effective Technological Measures to, the + Licensed Material if doing so restricts exercise of the + Licensed Rights by any recipient of the Licensed + Material. + + 6. No endorsement. Nothing in this Public License constitutes or + may be construed as permission to assert or imply that You + are, or that Your use of the Licensed Material is, connected + with, or sponsored, endorsed, or granted official status by, + the Licensor or others designated to receive attribution as + provided in Section 3(a)(1)(A)(i). + + b. Other rights. + + 1. Moral rights, such as the right of integrity, are not + licensed under this Public License, nor are publicity, + privacy, and/or other similar personality rights; however, to + the extent possible, the Licensor waives and/or agrees not to + assert any such rights held by the Licensor to the limited + extent necessary to allow You to exercise the Licensed + Rights, but not otherwise. + + 2. Patent and trademark rights are not licensed under this + Public License. + + 3. To the extent possible, the Licensor waives any right to + collect royalties from You for the exercise of the Licensed + Rights, whether directly or through a collecting society + under any voluntary or waivable statutory or compulsory + licensing scheme. In all other cases the Licensor expressly + reserves any right to collect such royalties, including when + the Licensed Material is used other than for NonCommercial + purposes. + + +Section 3 -- License Conditions. + +Your exercise of the Licensed Rights is expressly made subject to the +following conditions. + + a. Attribution. + + 1. If You Share the Licensed Material (including in modified + form), You must: + + a. retain the following if it is supplied by the Licensor + with the Licensed Material: + + i. identification of the creator(s) of the Licensed + Material and any others designated to receive + attribution, in any reasonable manner requested by + the Licensor (including by pseudonym if + designated); + + ii. a copyright notice; + + iii. a notice that refers to this Public License; + + iv. a notice that refers to the disclaimer of + warranties; + + v. a URI or hyperlink to the Licensed Material to the + extent reasonably practicable; + + b. indicate if You modified the Licensed Material and + retain an indication of any previous modifications; and + + c. indicate the Licensed Material is licensed under this + Public License, and include the text of, or the URI or + hyperlink to, this Public License. + + 2. You may satisfy the conditions in Section 3(a)(1) in any + reasonable manner based on the medium, means, and context in + which You Share the Licensed Material. For example, it may be + reasonable to satisfy the conditions by providing a URI or + hyperlink to a resource that includes the required + information. + + 3. If requested by the Licensor, You must remove any of the + information required by Section 3(a)(1)(A) to the extent + reasonably practicable. + + 4. If You Share Adapted Material You produce, the Adapter's + License You apply must not prevent recipients of the Adapted + Material from complying with this Public License. + + +Section 4 -- Sui Generis Database Rights. + +Where the Licensed Rights include Sui Generis Database Rights that +apply to Your use of the Licensed Material: + + a. for the avoidance of doubt, Section 2(a)(1) grants You the right + to extract, reuse, reproduce, and Share all or a substantial + portion of the contents of the database for NonCommercial purposes + only; + + b. if You include all or a substantial portion of the database + contents in a database in which You have Sui Generis Database + Rights, then the database in which You have Sui Generis Database + Rights (but not its individual contents) is Adapted Material; and + + c. You must comply with the conditions in Section 3(a) if You Share + all or a substantial portion of the contents of the database. + +For the avoidance of doubt, this Section 4 supplements and does not +replace Your obligations under this Public License where the Licensed +Rights include other Copyright and Similar Rights. + + +Section 5 -- Disclaimer of Warranties and Limitation of Liability. + + a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE + EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS + AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF + ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS, + IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION, + WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR + PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS, + ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT + KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT + ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU. + + b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE + TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION, + NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT, + INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES, + COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR + USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN + ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR + DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR + IN PART, THIS LIMITATION MAY NOT APPLY TO YOU. + + c. The disclaimer of warranties and limitation of liability provided + above shall be interpreted in a manner that, to the extent + possible, most closely approximates an absolute disclaimer and + waiver of all liability. + + +Section 6 -- Term and Termination. + + a. This Public License applies for the term of the Copyright and + Similar Rights licensed here. However, if You fail to comply with + this Public License, then Your rights under this Public License + terminate automatically. + + b. Where Your right to use the Licensed Material has terminated under + Section 6(a), it reinstates: + + 1. automatically as of the date the violation is cured, provided + it is cured within 30 days of Your discovery of the + violation; or + + 2. upon express reinstatement by the Licensor. + + For the avoidance of doubt, this Section 6(b) does not affect any + right the Licensor may have to seek remedies for Your violations + of this Public License. + + c. For the avoidance of doubt, the Licensor may also offer the + Licensed Material under separate terms or conditions or stop + distributing the Licensed Material at any time; however, doing so + will not terminate this Public License. + + d. Sections 1, 5, 6, 7, and 8 survive termination of this Public + License. + + +Section 7 -- Other Terms and Conditions. + + a. The Licensor shall not be bound by any additional or different + terms or conditions communicated by You unless expressly agreed. + + b. Any arrangements, understandings, or agreements regarding the + Licensed Material not stated herein are separate from and + independent of the terms and conditions of this Public License. + + +Section 8 -- Interpretation. + + a. For the avoidance of doubt, this Public License does not, and + shall not be interpreted to, reduce, limit, restrict, or impose + conditions on any use of the Licensed Material that could lawfully + be made without permission under this Public License. + + b. To the extent possible, if any provision of this Public License is + deemed unenforceable, it shall be automatically reformed to the + minimum extent necessary to make it enforceable. If the provision + cannot be reformed, it shall be severed from this Public License + without affecting the enforceability of the remaining terms and + conditions. + + c. No term or condition of this Public License will be waived and no + failure to comply consented to unless expressly agreed to by the + Licensor. + + d. Nothing in this Public License constitutes or may be interpreted + as a limitation upon, or waiver of, any privileges and immunities + that apply to the Licensor or You, including from the legal + processes of any jurisdiction or authority. + +======================================================================= + +Creative Commons is not a party to its public +licenses. Notwithstanding, Creative Commons may elect to apply one of +its public licenses to material it publishes and in those instances +will be considered the "Licensor." The text of the Creative Commons +public licenses is dedicated to the public domain under the CC0 Public +Domain Dedication. Except for the limited purpose of indicating that +material is shared under a Creative Commons public license or as +otherwise permitted by the Creative Commons policies published at +creativecommons.org/policies, Creative Commons does not authorize the +use of the trademark "Creative Commons" or any other trademark or logo +of Creative Commons without its prior written consent including, +without limitation, in connection with any unauthorized modifications +to any of its public licenses or any other arrangements, +understandings, or agreements concerning use of licensed material. For +the avoidance of doubt, this paragraph does not form part of the +public licenses. + +Creative Commons may be contacted at creativecommons.org. diff --git a/models/stylegan/stylegan_tf/README.md b/models/stylegan/stylegan_tf/README.md new file mode 100644 index 0000000000000000000000000000000000000000..a86a64a60a14ccea6dc3c0a0048a243750fe98fe --- /dev/null +++ b/models/stylegan/stylegan_tf/README.md @@ -0,0 +1,232 @@ +## StyleGAN — Official TensorFlow Implementation +![Python 3.6](https://img.shields.io/badge/python-3.6-green.svg?style=plastic) +![TensorFlow 1.10](https://img.shields.io/badge/tensorflow-1.10-green.svg?style=plastic) +![cuDNN 7.3.1](https://img.shields.io/badge/cudnn-7.3.1-green.svg?style=plastic) +![License CC BY-NC](https://img.shields.io/badge/license-CC_BY--NC-green.svg?style=plastic) + +![Teaser image](./stylegan-teaser.png) +**Picture:** *These people are not real – they were produced by our generator that allows control over different aspects of the image.* + +This repository contains the official TensorFlow implementation of the following paper: + +> **A Style-Based Generator Architecture for Generative Adversarial Networks**
+> Tero Karras (NVIDIA), Samuli Laine (NVIDIA), Timo Aila (NVIDIA)
+> https://arxiv.org/abs/1812.04948 +> +> **Abstract:** *We propose an alternative generator architecture for generative adversarial networks, borrowing from style transfer literature. The new architecture leads to an automatically learned, unsupervised separation of high-level attributes (e.g., pose and identity when trained on human faces) and stochastic variation in the generated images (e.g., freckles, hair), and it enables intuitive, scale-specific control of the synthesis. The new generator improves the state-of-the-art in terms of traditional distribution quality metrics, leads to demonstrably better interpolation properties, and also better disentangles the latent factors of variation. To quantify interpolation quality and disentanglement, we propose two new, automated methods that are applicable to any generator architecture. Finally, we introduce a new, highly varied and high-quality dataset of human faces.* + +For business inquiries, please contact [researchinquiries@nvidia.com](mailto:researchinquiries@nvidia.com)
+For press and other inquiries, please contact Hector Marinez at [hmarinez@nvidia.com](mailto:hmarinez@nvidia.com)
+ +**★★★ NEW: StyleGAN2 is available at [https://github.com/NVlabs/stylegan2](https://github.com/NVlabs/stylegan2) ★★★** + +## Resources + +Material related to our paper is available via the following links: + +- Paper: https://arxiv.org/abs/1812.04948 +- Video: https://youtu.be/kSLJriaOumA +- Code: https://github.com/NVlabs/stylegan +- FFHQ: https://github.com/NVlabs/ffhq-dataset + +Additional material can be found on Google Drive: + +| Path | Description +| :--- | :---------- +| [StyleGAN](https://drive.google.com/open?id=1uka3a1noXHAydRPRbknqwKVGODvnmUBX) | Main folder. +| ├  [stylegan-paper.pdf](https://drive.google.com/open?id=1v-HkF3Ehrpon7wVIx4r5DLcko_U_V6Lt) | High-quality version of the paper PDF. +| ├  [stylegan-video.mp4](https://drive.google.com/open?id=1uzwkZHQX_9pYg1i0d1Nbe3D9xPO8-qBf) | High-quality version of the result video. +| ├  [images](https://drive.google.com/open?id=1-l46akONUWF6LCpDoeq63H53rD7MeiTd) | Example images produced using our generator. +| │  ├  [representative-images](https://drive.google.com/open?id=1ToY5P4Vvf5_c3TyUizQ8fckFFoFtBvD8) | High-quality images to be used in articles, blog posts, etc. +| │  └  [100k-generated-images](https://drive.google.com/open?id=100DJ0QXyG89HZzB4w2Cbyf4xjNK54cQ1) | 100,000 generated images for different amounts of truncation. +| │     ├  [ffhq-1024x1024](https://drive.google.com/open?id=14lm8VRN1pr4g_KVe6_LvyDX1PObst6d4) | Generated using Flickr-Faces-HQ dataset at 1024×1024. +| │     ├  [bedrooms-256x256](https://drive.google.com/open?id=1Vxz9fksw4kgjiHrvHkX4Hze4dyThFW6t) | Generated using LSUN Bedroom dataset at 256×256. +| │     ├  [cars-512x384](https://drive.google.com/open?id=1MFCvOMdLE2_mpeLPTiDw5dxc2CRuKkzS) | Generated using LSUN Car dataset at 512×384. +| │     └  [cats-256x256](https://drive.google.com/open?id=1gq-Gj3GRFiyghTPKhp8uDMA9HV_0ZFWQ) | Generated using LSUN Cat dataset at 256×256. +| ├  [videos](https://drive.google.com/open?id=1N8pOd_Bf8v89NGUaROdbD8-ayLPgyRRo) | Example videos produced using our generator. +| │  └  [high-quality-video-clips](https://drive.google.com/open?id=1NFO7_vH0t98J13ckJYFd7kuaTkyeRJ86) | Individual segments of the result video as high-quality MP4. +| ├  [ffhq-dataset](https://drive.google.com/open?id=1u2xu7bSrWxrbUxk-dT-UvEJq8IjdmNTP) | Raw data for the [Flickr-Faces-HQ dataset](https://github.com/NVlabs/ffhq-dataset). +| └  [networks](https://drive.google.com/open?id=1MASQyN5m0voPcx7-9K0r5gObhvvPups7) | Pre-trained networks as pickled instances of [dnnlib.tflib.Network](./dnnlib/tflib/network.py). +|    ├  [stylegan-ffhq-1024x1024.pkl](https://drive.google.com/uc?id=1MEGjdvVpUsu1jB4zrXZN7Y4kBBOzizDQ) | StyleGAN trained with Flickr-Faces-HQ dataset at 1024×1024. +|    ├  [stylegan-celebahq-1024x1024.pkl](https://drive.google.com/uc?id=1MGqJl28pN4t7SAtSrPdSRJSQJqahkzUf) | StyleGAN trained with CelebA-HQ dataset at 1024×1024. +|    ├  [stylegan-bedrooms-256x256.pkl](https://drive.google.com/uc?id=1MOSKeGF0FJcivpBI7s63V9YHloUTORiF) | StyleGAN trained with LSUN Bedroom dataset at 256×256. +|    ├  [stylegan-cars-512x384.pkl](https://drive.google.com/uc?id=1MJ6iCfNtMIRicihwRorsM3b7mmtmK9c3) | StyleGAN trained with LSUN Car dataset at 512×384. +|    ├  [stylegan-cats-256x256.pkl](https://drive.google.com/uc?id=1MQywl0FNt6lHu8E_EUqnRbviagS7fbiJ) | StyleGAN trained with LSUN Cat dataset at 256×256. +|    └  [metrics](https://drive.google.com/open?id=1MvYdWCBuMfnoYGptRH-AgKLbPTsIQLhl) | Auxiliary networks for the quality and disentanglement metrics. +|       ├  [inception_v3_features.pkl](https://drive.google.com/uc?id=1MzTY44rLToO5APn8TZmfR7_ENSe5aZUn) | Standard [Inception-v3](https://arxiv.org/abs/1512.00567) classifier that outputs a raw feature vector. +|       ├  [vgg16_zhang_perceptual.pkl](https://drive.google.com/uc?id=1N2-m9qszOeVC9Tq77WxsLnuWwOedQiD2) | Standard [LPIPS](https://arxiv.org/abs/1801.03924) metric to estimate perceptual similarity. +|       ├  [celebahq-classifier-00-male.pkl](https://drive.google.com/uc?id=1Q5-AI6TwWhCVM7Muu4tBM7rp5nG_gmCX) | Binary classifier trained to detect a single attribute of CelebA-HQ. +|       └ ⋯ | Please see the file listing for remaining networks. + +## Licenses + +All material, excluding the Flickr-Faces-HQ dataset, is made available under [Creative Commons BY-NC 4.0](https://creativecommons.org/licenses/by-nc/4.0/) license by NVIDIA Corporation. You can **use, redistribute, and adapt** the material for **non-commercial purposes**, as long as you give appropriate credit by **citing our paper** and **indicating any changes** that you've made. + +For license information regarding the FFHQ dataset, please refer to the [Flickr-Faces-HQ repository](https://github.com/NVlabs/ffhq-dataset). + +`inception_v3_features.pkl` and `inception_v3_softmax.pkl` are derived from the pre-trained [Inception-v3](https://arxiv.org/abs/1512.00567) network by Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jonathon Shlens, and Zbigniew Wojna. The network was originally shared under [Apache 2.0](https://github.com/tensorflow/models/blob/master/LICENSE) license on the [TensorFlow Models](https://github.com/tensorflow/models) repository. + +`vgg16.pkl` and `vgg16_zhang_perceptual.pkl` are derived from the pre-trained [VGG-16](https://arxiv.org/abs/1409.1556) network by Karen Simonyan and Andrew Zisserman. The network was originally shared under [Creative Commons BY 4.0](https://creativecommons.org/licenses/by/4.0/) license on the [Very Deep Convolutional Networks for Large-Scale Visual Recognition](http://www.robots.ox.ac.uk/~vgg/research/very_deep/) project page. + +`vgg16_zhang_perceptual.pkl` is further derived from the pre-trained [LPIPS](https://arxiv.org/abs/1801.03924) weights by Richard Zhang, Phillip Isola, Alexei A. Efros, Eli Shechtman, and Oliver Wang. The weights were originally shared under [BSD 2-Clause "Simplified" License](https://github.com/richzhang/PerceptualSimilarity/blob/master/LICENSE) on the [PerceptualSimilarity](https://github.com/richzhang/PerceptualSimilarity) repository. + +## System requirements + +* Both Linux and Windows are supported, but we strongly recommend Linux for performance and compatibility reasons. +* 64-bit Python 3.6 installation. We recommend Anaconda3 with numpy 1.14.3 or newer. +* TensorFlow 1.10.0 or newer with GPU support. +* One or more high-end NVIDIA GPUs with at least 11GB of DRAM. We recommend NVIDIA DGX-1 with 8 Tesla V100 GPUs. +* NVIDIA driver 391.35 or newer, CUDA toolkit 9.0 or newer, cuDNN 7.3.1 or newer. + +## Using pre-trained networks + +A minimal example of using a pre-trained StyleGAN generator is given in [pretrained_example.py](./pretrained_example.py). When executed, the script downloads a pre-trained StyleGAN generator from Google Drive and uses it to generate an image: + +``` +> python pretrained_example.py +Downloading https://drive.google.com/uc?id=1MEGjdvVpUsu1jB4zrXZN7Y4kBBOzizDQ .... done + +Gs Params OutputShape WeightShape +--- --- --- --- +latents_in - (?, 512) - +... +images_out - (?, 3, 1024, 1024) - +--- --- --- --- +Total 26219627 + +> ls results +example.png # https://drive.google.com/uc?id=1UDLT_zb-rof9kKH0GwiJW_bS9MoZi8oP +``` + +A more advanced example is given in [generate_figures.py](./generate_figures.py). The script reproduces the figures from our paper in order to illustrate style mixing, noise inputs, and truncation: +``` +> python generate_figures.py +results/figure02-uncurated-ffhq.png # https://drive.google.com/uc?id=1U3r1xgcD7o-Fd0SBRpq8PXYajm7_30cu +results/figure03-style-mixing.png # https://drive.google.com/uc?id=1U-nlMDtpnf1RcYkaFQtbh5oxnhA97hy6 +results/figure04-noise-detail.png # https://drive.google.com/uc?id=1UX3m39u_DTU6eLnEW6MqGzbwPFt2R9cG +results/figure05-noise-components.png # https://drive.google.com/uc?id=1UQKPcvYVeWMRccGMbs2pPD9PVv1QDyp_ +results/figure08-truncation-trick.png # https://drive.google.com/uc?id=1ULea0C12zGlxdDQFNLXOWZCHi3QNfk_v +results/figure10-uncurated-bedrooms.png # https://drive.google.com/uc?id=1UEBnms1XMfj78OHj3_cx80mUf_m9DUJr +results/figure11-uncurated-cars.png # https://drive.google.com/uc?id=1UO-4JtAs64Kun5vIj10UXqAJ1d5Ir1Ke +results/figure12-uncurated-cats.png # https://drive.google.com/uc?id=1USnJc14prlu3QAYxstrtlfXC9sDWPA-W +``` + +The pre-trained networks are stored as standard pickle files on Google Drive: + +``` +# Load pre-trained network. +url = 'https://drive.google.com/uc?id=1MEGjdvVpUsu1jB4zrXZN7Y4kBBOzizDQ' # karras2019stylegan-ffhq-1024x1024.pkl +with dnnlib.util.open_url(url, cache_dir=config.cache_dir) as f: + _G, _D, Gs = pickle.load(f) + # _G = Instantaneous snapshot of the generator. Mainly useful for resuming a previous training run. + # _D = Instantaneous snapshot of the discriminator. Mainly useful for resuming a previous training run. + # Gs = Long-term average of the generator. Yields higher-quality results than the instantaneous snapshot. +``` + +The above code downloads the file and unpickles it to yield 3 instances of [dnnlib.tflib.Network](./dnnlib/tflib/network.py). To generate images, you will typically want to use `Gs` – the other two networks are provided for completeness. In order for `pickle.load()` to work, you will need to have the `dnnlib` source directory in your PYTHONPATH and a `tf.Session` set as default. The session can initialized by calling `dnnlib.tflib.init_tf()`. + +There are three ways to use the pre-trained generator: + +1. Use `Gs.run()` for immediate-mode operation where the inputs and outputs are numpy arrays: + ``` + # Pick latent vector. + rnd = np.random.RandomState(5) + latents = rnd.randn(1, Gs.input_shape[1]) + + # Generate image. + fmt = dict(func=tflib.convert_images_to_uint8, nchw_to_nhwc=True) + images = Gs.run(latents, None, truncation_psi=0.7, randomize_noise=True, output_transform=fmt) + ``` + The first argument is a batch of latent vectors of shape `[num, 512]`. The second argument is reserved for class labels (not used by StyleGAN). The remaining keyword arguments are optional and can be used to further modify the operation (see below). The output is a batch of images, whose format is dictated by the `output_transform` argument. + +2. Use `Gs.get_output_for()` to incorporate the generator as a part of a larger TensorFlow expression: + ``` + latents = tf.random_normal([self.minibatch_per_gpu] + Gs_clone.input_shape[1:]) + images = Gs_clone.get_output_for(latents, None, is_validation=True, randomize_noise=True) + images = tflib.convert_images_to_uint8(images) + result_expr.append(inception_clone.get_output_for(images)) + ``` + The above code is from [metrics/frechet_inception_distance.py](./metrics/frechet_inception_distance.py). It generates a batch of random images and feeds them directly to the [Inception-v3](https://arxiv.org/abs/1512.00567) network without having to convert the data to numpy arrays in between. + +3. Look up `Gs.components.mapping` and `Gs.components.synthesis` to access individual sub-networks of the generator. Similar to `Gs`, the sub-networks are represented as independent instances of [dnnlib.tflib.Network](./dnnlib/tflib/network.py): + ``` + src_latents = np.stack(np.random.RandomState(seed).randn(Gs.input_shape[1]) for seed in src_seeds) + src_dlatents = Gs.components.mapping.run(src_latents, None) # [seed, layer, component] + src_images = Gs.components.synthesis.run(src_dlatents, randomize_noise=False, **synthesis_kwargs) + ``` + The above code is from [generate_figures.py](./generate_figures.py). It first transforms a batch of latent vectors into the intermediate *W* space using the mapping network and then turns these vectors into a batch of images using the synthesis network. The `dlatents` array stores a separate copy of the same *w* vector for each layer of the synthesis network to facilitate style mixing. + +The exact details of the generator are defined in [training/networks_stylegan.py](./training/networks_stylegan.py) (see `G_style`, `G_mapping`, and `G_synthesis`). The following keyword arguments can be specified to modify the behavior when calling `run()` and `get_output_for()`: + +* `truncation_psi` and `truncation_cutoff` control the truncation trick that that is performed by default when using `Gs` (ψ=0.7, cutoff=8). It can be disabled by setting `truncation_psi=1` or `is_validation=True`, and the image quality can be further improved at the cost of variation by setting e.g. `truncation_psi=0.5`. Note that truncation is always disabled when using the sub-networks directly. The average *w* needed to manually perform the truncation trick can be looked up using `Gs.get_var('dlatent_avg')`. + +* `randomize_noise` determines whether to use re-randomize the noise inputs for each generated image (`True`, default) or whether to use specific noise values for the entire minibatch (`False`). The specific values can be accessed via the `tf.Variable` instances that are found using `[var for name, var in Gs.components.synthesis.vars.items() if name.startswith('noise')]`. + +* When using the mapping network directly, you can specify `dlatent_broadcast=None` to disable the automatic duplication of `dlatents` over the layers of the synthesis network. + +* Runtime performance can be fine-tuned via `structure='fixed'` and `dtype='float16'`. The former disables support for progressive growing, which is not needed for a fully-trained generator, and the latter performs all computation using half-precision floating point arithmetic. + +## Preparing datasets for training + +The training and evaluation scripts operate on datasets stored as multi-resolution TFRecords. Each dataset is represented by a directory containing the same image data in several resolutions to enable efficient streaming. There is a separate *.tfrecords file for each resolution, and if the dataset contains labels, they are stored in a separate file as well. By default, the scripts expect to find the datasets at `datasets//-.tfrecords`. The directory can be changed by editing [config.py](./config.py): + +``` +result_dir = 'results' +data_dir = 'datasets' +cache_dir = 'cache' +``` + +To obtain the FFHQ dataset (`datasets/ffhq`), please refer to the [Flickr-Faces-HQ repository](https://github.com/NVlabs/ffhq-dataset). + +To obtain the CelebA-HQ dataset (`datasets/celebahq`), please refer to the [Progressive GAN repository](https://github.com/tkarras/progressive_growing_of_gans). + +To obtain other datasets, including LSUN, please consult their corresponding project pages. The datasets can be converted to multi-resolution TFRecords using the provided [dataset_tool.py](./dataset_tool.py): + +``` +> python dataset_tool.py create_lsun datasets/lsun-bedroom-full ~/lsun/bedroom_lmdb --resolution 256 +> python dataset_tool.py create_lsun_wide datasets/lsun-car-512x384 ~/lsun/car_lmdb --width 512 --height 384 +> python dataset_tool.py create_lsun datasets/lsun-cat-full ~/lsun/cat_lmdb --resolution 256 +> python dataset_tool.py create_cifar10 datasets/cifar10 ~/cifar10 +> python dataset_tool.py create_from_images datasets/custom-dataset ~/custom-images +``` + +## Training networks + +Once the datasets are set up, you can train your own StyleGAN networks as follows: + +1. Edit [train.py](./train.py) to specify the dataset and training configuration by uncommenting or editing specific lines. +2. Run the training script with `python train.py`. +3. The results are written to a newly created directory `results/-`. +4. The training may take several days (or weeks) to complete, depending on the configuration. + +By default, `train.py` is configured to train the highest-quality StyleGAN (configuration F in Table 1) for the FFHQ dataset at 1024×1024 resolution using 8 GPUs. Please note that we have used 8 GPUs in all of our experiments. Training with fewer GPUs may not produce identical results – if you wish to compare against our technique, we strongly recommend using the same number of GPUs. + +Expected training times for the default configuration using Tesla V100 GPUs: + +| GPUs | 1024×1024 | 512×512 | 256×256 | +| :--- | :-------------- | :------------ | :------------ | +| 1 | 41 days 4 hours | 24 days 21 hours | 14 days 22 hours | +| 2 | 21 days 22 hours | 13 days 7 hours | 9 days 5 hours | +| 4 | 11 days 8 hours | 7 days 0 hours | 4 days 21 hours | +| 8 | 6 days 14 hours | 4 days 10 hours | 3 days 8 hours | + +## Evaluating quality and disentanglement + +The quality and disentanglement metrics used in our paper can be evaluated using [run_metrics.py](./run_metrics.py). By default, the script will evaluate the Fréchet Inception Distance (`fid50k`) for the pre-trained FFHQ generator and write the results into a newly created directory under `results`. The exact behavior can be changed by uncommenting or editing specific lines in [run_metrics.py](./run_metrics.py). + +Expected evaluation time and results for the pre-trained FFHQ generator using one Tesla V100 GPU: + +| Metric | Time | Result | Description +| :----- | :--- | :----- | :---------- +| fid50k | 16 min | 4.4159 | Fréchet Inception Distance using 50,000 images. +| ppl_zfull | 55 min | 664.8854 | Perceptual Path Length for full paths in *Z*. +| ppl_wfull | 55 min | 233.3059 | Perceptual Path Length for full paths in *W*. +| ppl_zend | 55 min | 666.1057 | Perceptual Path Length for path endpoints in *Z*. +| ppl_wend | 55 min | 197.2266 | Perceptual Path Length for path endpoints in *W*. +| ls | 10 hours | z: 165.0106
w: 3.7447 | Linear Separability in *Z* and *W*. + +Please note that the exact results may vary from run to run due to the non-deterministic nature of TensorFlow. + +## Acknowledgements + +We thank Jaakko Lehtinen, David Luebke, and Tuomas Kynkäänniemi for in-depth discussions and helpful comments; Janne Hellsten, Tero Kuosmanen, and Pekka Jänis for compute infrastructure and help with the code release. diff --git a/models/stylegan/stylegan_tf/config.py b/models/stylegan/stylegan_tf/config.py new file mode 100644 index 0000000000000000000000000000000000000000..dcf45253e888806dc58d8dfc994d2dad96527172 --- /dev/null +++ b/models/stylegan/stylegan_tf/config.py @@ -0,0 +1,18 @@ +# Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved. +# +# This work is licensed under the Creative Commons Attribution-NonCommercial +# 4.0 International License. To view a copy of this license, visit +# http://creativecommons.org/licenses/by-nc/4.0/ or send a letter to +# Creative Commons, PO Box 1866, Mountain View, CA 94042, USA. + +"""Global configuration.""" + +#---------------------------------------------------------------------------- +# Paths. + +result_dir = 'results' +data_dir = 'datasets' +cache_dir = 'cache' +run_dir_ignore = ['results', 'datasets', 'cache'] + +#---------------------------------------------------------------------------- diff --git a/models/stylegan/stylegan_tf/dataset_tool.py b/models/stylegan/stylegan_tf/dataset_tool.py new file mode 100644 index 0000000000000000000000000000000000000000..4ddfe448e2ccaa30e04ad4b49761d406846c962f --- /dev/null +++ b/models/stylegan/stylegan_tf/dataset_tool.py @@ -0,0 +1,645 @@ +# Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved. +# +# This work is licensed under the Creative Commons Attribution-NonCommercial +# 4.0 International License. To view a copy of this license, visit +# http://creativecommons.org/licenses/by-nc/4.0/ or send a letter to +# Creative Commons, PO Box 1866, Mountain View, CA 94042, USA. + +"""Tool for creating multi-resolution TFRecords datasets for StyleGAN and ProGAN.""" + +# pylint: disable=too-many-lines +import os +import sys +import glob +import argparse +import threading +import six.moves.queue as Queue # pylint: disable=import-error +import traceback +import numpy as np +import tensorflow as tf +import PIL.Image +import dnnlib.tflib as tflib + +from training import dataset + +#---------------------------------------------------------------------------- + +def error(msg): + print('Error: ' + msg) + exit(1) + +#---------------------------------------------------------------------------- + +class TFRecordExporter: + def __init__(self, tfrecord_dir, expected_images, print_progress=True, progress_interval=10): + self.tfrecord_dir = tfrecord_dir + self.tfr_prefix = os.path.join(self.tfrecord_dir, os.path.basename(self.tfrecord_dir)) + self.expected_images = expected_images + self.cur_images = 0 + self.shape = None + self.resolution_log2 = None + self.tfr_writers = [] + self.print_progress = print_progress + self.progress_interval = progress_interval + + if self.print_progress: + print('Creating dataset "%s"' % tfrecord_dir) + if not os.path.isdir(self.tfrecord_dir): + os.makedirs(self.tfrecord_dir) + assert os.path.isdir(self.tfrecord_dir) + + def close(self): + if self.print_progress: + print('%-40s\r' % 'Flushing data...', end='', flush=True) + for tfr_writer in self.tfr_writers: + tfr_writer.close() + self.tfr_writers = [] + if self.print_progress: + print('%-40s\r' % '', end='', flush=True) + print('Added %d images.' % self.cur_images) + + def choose_shuffled_order(self): # Note: Images and labels must be added in shuffled order. + order = np.arange(self.expected_images) + np.random.RandomState(123).shuffle(order) + return order + + def add_image(self, img): + if self.print_progress and self.cur_images % self.progress_interval == 0: + print('%d / %d\r' % (self.cur_images, self.expected_images), end='', flush=True) + if self.shape is None: + self.shape = img.shape + self.resolution_log2 = int(np.log2(self.shape[1])) + assert self.shape[0] in [1, 3] + assert self.shape[1] == self.shape[2] + assert self.shape[1] == 2**self.resolution_log2 + tfr_opt = tf.python_io.TFRecordOptions(tf.python_io.TFRecordCompressionType.NONE) + for lod in range(self.resolution_log2 - 1): + tfr_file = self.tfr_prefix + '-r%02d.tfrecords' % (self.resolution_log2 - lod) + self.tfr_writers.append(tf.python_io.TFRecordWriter(tfr_file, tfr_opt)) + assert img.shape == self.shape + for lod, tfr_writer in enumerate(self.tfr_writers): + if lod: + img = img.astype(np.float32) + img = (img[:, 0::2, 0::2] + img[:, 0::2, 1::2] + img[:, 1::2, 0::2] + img[:, 1::2, 1::2]) * 0.25 + quant = np.rint(img).clip(0, 255).astype(np.uint8) + ex = tf.train.Example(features=tf.train.Features(feature={ + 'shape': tf.train.Feature(int64_list=tf.train.Int64List(value=quant.shape)), + 'data': tf.train.Feature(bytes_list=tf.train.BytesList(value=[quant.tostring()]))})) + tfr_writer.write(ex.SerializeToString()) + self.cur_images += 1 + + def add_labels(self, labels): + if self.print_progress: + print('%-40s\r' % 'Saving labels...', end='', flush=True) + assert labels.shape[0] == self.cur_images + with open(self.tfr_prefix + '-rxx.labels', 'wb') as f: + np.save(f, labels.astype(np.float32)) + + def __enter__(self): + return self + + def __exit__(self, *args): + self.close() + +#---------------------------------------------------------------------------- + +class ExceptionInfo(object): + def __init__(self): + self.value = sys.exc_info()[1] + self.traceback = traceback.format_exc() + +#---------------------------------------------------------------------------- + +class WorkerThread(threading.Thread): + def __init__(self, task_queue): + threading.Thread.__init__(self) + self.task_queue = task_queue + + def run(self): + while True: + func, args, result_queue = self.task_queue.get() + if func is None: + break + try: + result = func(*args) + except: + result = ExceptionInfo() + result_queue.put((result, args)) + +#---------------------------------------------------------------------------- + +class ThreadPool(object): + def __init__(self, num_threads): + assert num_threads >= 1 + self.task_queue = Queue.Queue() + self.result_queues = dict() + self.num_threads = num_threads + for _idx in range(self.num_threads): + thread = WorkerThread(self.task_queue) + thread.daemon = True + thread.start() + + def add_task(self, func, args=()): + assert hasattr(func, '__call__') # must be a function + if func not in self.result_queues: + self.result_queues[func] = Queue.Queue() + self.task_queue.put((func, args, self.result_queues[func])) + + def get_result(self, func): # returns (result, args) + result, args = self.result_queues[func].get() + if isinstance(result, ExceptionInfo): + print('\n\nWorker thread caught an exception:\n' + result.traceback) + raise result.value + return result, args + + def finish(self): + for _idx in range(self.num_threads): + self.task_queue.put((None, (), None)) + + def __enter__(self): # for 'with' statement + return self + + def __exit__(self, *excinfo): + self.finish() + + def process_items_concurrently(self, item_iterator, process_func=lambda x: x, pre_func=lambda x: x, post_func=lambda x: x, max_items_in_flight=None): + if max_items_in_flight is None: max_items_in_flight = self.num_threads * 4 + assert max_items_in_flight >= 1 + results = [] + retire_idx = [0] + + def task_func(prepared, _idx): + return process_func(prepared) + + def retire_result(): + processed, (_prepared, idx) = self.get_result(task_func) + results[idx] = processed + while retire_idx[0] < len(results) and results[retire_idx[0]] is not None: + yield post_func(results[retire_idx[0]]) + results[retire_idx[0]] = None + retire_idx[0] += 1 + + for idx, item in enumerate(item_iterator): + prepared = pre_func(item) + results.append(None) + self.add_task(func=task_func, args=(prepared, idx)) + while retire_idx[0] < idx - max_items_in_flight + 2: + for res in retire_result(): yield res + while retire_idx[0] < len(results): + for res in retire_result(): yield res + +#---------------------------------------------------------------------------- + +def display(tfrecord_dir): + print('Loading dataset "%s"' % tfrecord_dir) + tflib.init_tf({'gpu_options.allow_growth': True}) + dset = dataset.TFRecordDataset(tfrecord_dir, max_label_size='full', repeat=False, shuffle_mb=0) + tflib.init_uninitialized_vars() + import cv2 # pip install opencv-python + + idx = 0 + while True: + try: + images, labels = dset.get_minibatch_np(1) + except tf.errors.OutOfRangeError: + break + if idx == 0: + print('Displaying images') + cv2.namedWindow('dataset_tool') + print('Press SPACE or ENTER to advance, ESC to exit') + print('\nidx = %-8d\nlabel = %s' % (idx, labels[0].tolist())) + cv2.imshow('dataset_tool', images[0].transpose(1, 2, 0)[:, :, ::-1]) # CHW => HWC, RGB => BGR + idx += 1 + if cv2.waitKey() == 27: + break + print('\nDisplayed %d images.' % idx) + +#---------------------------------------------------------------------------- + +def extract(tfrecord_dir, output_dir): + print('Loading dataset "%s"' % tfrecord_dir) + tflib.init_tf({'gpu_options.allow_growth': True}) + dset = dataset.TFRecordDataset(tfrecord_dir, max_label_size=0, repeat=False, shuffle_mb=0) + tflib.init_uninitialized_vars() + + print('Extracting images to "%s"' % output_dir) + if not os.path.isdir(output_dir): + os.makedirs(output_dir) + idx = 0 + while True: + if idx % 10 == 0: + print('%d\r' % idx, end='', flush=True) + try: + images, _labels = dset.get_minibatch_np(1) + except tf.errors.OutOfRangeError: + break + if images.shape[1] == 1: + img = PIL.Image.fromarray(images[0][0], 'L') + else: + img = PIL.Image.fromarray(images[0].transpose(1, 2, 0), 'RGB') + img.save(os.path.join(output_dir, 'img%08d.png' % idx)) + idx += 1 + print('Extracted %d images.' % idx) + +#---------------------------------------------------------------------------- + +def compare(tfrecord_dir_a, tfrecord_dir_b, ignore_labels): + max_label_size = 0 if ignore_labels else 'full' + print('Loading dataset "%s"' % tfrecord_dir_a) + tflib.init_tf({'gpu_options.allow_growth': True}) + dset_a = dataset.TFRecordDataset(tfrecord_dir_a, max_label_size=max_label_size, repeat=False, shuffle_mb=0) + print('Loading dataset "%s"' % tfrecord_dir_b) + dset_b = dataset.TFRecordDataset(tfrecord_dir_b, max_label_size=max_label_size, repeat=False, shuffle_mb=0) + tflib.init_uninitialized_vars() + + print('Comparing datasets') + idx = 0 + identical_images = 0 + identical_labels = 0 + while True: + if idx % 100 == 0: + print('%d\r' % idx, end='', flush=True) + try: + images_a, labels_a = dset_a.get_minibatch_np(1) + except tf.errors.OutOfRangeError: + images_a, labels_a = None, None + try: + images_b, labels_b = dset_b.get_minibatch_np(1) + except tf.errors.OutOfRangeError: + images_b, labels_b = None, None + if images_a is None or images_b is None: + if images_a is not None or images_b is not None: + print('Datasets contain different number of images') + break + if images_a.shape == images_b.shape and np.all(images_a == images_b): + identical_images += 1 + else: + print('Image %d is different' % idx) + if labels_a.shape == labels_b.shape and np.all(labels_a == labels_b): + identical_labels += 1 + else: + print('Label %d is different' % idx) + idx += 1 + print('Identical images: %d / %d' % (identical_images, idx)) + if not ignore_labels: + print('Identical labels: %d / %d' % (identical_labels, idx)) + +#---------------------------------------------------------------------------- + +def create_mnist(tfrecord_dir, mnist_dir): + print('Loading MNIST from "%s"' % mnist_dir) + import gzip + with gzip.open(os.path.join(mnist_dir, 'train-images-idx3-ubyte.gz'), 'rb') as file: + images = np.frombuffer(file.read(), np.uint8, offset=16) + with gzip.open(os.path.join(mnist_dir, 'train-labels-idx1-ubyte.gz'), 'rb') as file: + labels = np.frombuffer(file.read(), np.uint8, offset=8) + images = images.reshape(-1, 1, 28, 28) + images = np.pad(images, [(0,0), (0,0), (2,2), (2,2)], 'constant', constant_values=0) + assert images.shape == (60000, 1, 32, 32) and images.dtype == np.uint8 + assert labels.shape == (60000,) and labels.dtype == np.uint8 + assert np.min(images) == 0 and np.max(images) == 255 + assert np.min(labels) == 0 and np.max(labels) == 9 + onehot = np.zeros((labels.size, np.max(labels) + 1), dtype=np.float32) + onehot[np.arange(labels.size), labels] = 1.0 + + with TFRecordExporter(tfrecord_dir, images.shape[0]) as tfr: + order = tfr.choose_shuffled_order() + for idx in range(order.size): + tfr.add_image(images[order[idx]]) + tfr.add_labels(onehot[order]) + +#---------------------------------------------------------------------------- + +def create_mnistrgb(tfrecord_dir, mnist_dir, num_images=1000000, random_seed=123): + print('Loading MNIST from "%s"' % mnist_dir) + import gzip + with gzip.open(os.path.join(mnist_dir, 'train-images-idx3-ubyte.gz'), 'rb') as file: + images = np.frombuffer(file.read(), np.uint8, offset=16) + images = images.reshape(-1, 28, 28) + images = np.pad(images, [(0,0), (2,2), (2,2)], 'constant', constant_values=0) + assert images.shape == (60000, 32, 32) and images.dtype == np.uint8 + assert np.min(images) == 0 and np.max(images) == 255 + + with TFRecordExporter(tfrecord_dir, num_images) as tfr: + rnd = np.random.RandomState(random_seed) + for _idx in range(num_images): + tfr.add_image(images[rnd.randint(images.shape[0], size=3)]) + +#---------------------------------------------------------------------------- + +def create_cifar10(tfrecord_dir, cifar10_dir): + print('Loading CIFAR-10 from "%s"' % cifar10_dir) + import pickle + images = [] + labels = [] + for batch in range(1, 6): + with open(os.path.join(cifar10_dir, 'data_batch_%d' % batch), 'rb') as file: + data = pickle.load(file, encoding='latin1') + images.append(data['data'].reshape(-1, 3, 32, 32)) + labels.append(data['labels']) + images = np.concatenate(images) + labels = np.concatenate(labels) + assert images.shape == (50000, 3, 32, 32) and images.dtype == np.uint8 + assert labels.shape == (50000,) and labels.dtype == np.int32 + assert np.min(images) == 0 and np.max(images) == 255 + assert np.min(labels) == 0 and np.max(labels) == 9 + onehot = np.zeros((labels.size, np.max(labels) + 1), dtype=np.float32) + onehot[np.arange(labels.size), labels] = 1.0 + + with TFRecordExporter(tfrecord_dir, images.shape[0]) as tfr: + order = tfr.choose_shuffled_order() + for idx in range(order.size): + tfr.add_image(images[order[idx]]) + tfr.add_labels(onehot[order]) + +#---------------------------------------------------------------------------- + +def create_cifar100(tfrecord_dir, cifar100_dir): + print('Loading CIFAR-100 from "%s"' % cifar100_dir) + import pickle + with open(os.path.join(cifar100_dir, 'train'), 'rb') as file: + data = pickle.load(file, encoding='latin1') + images = data['data'].reshape(-1, 3, 32, 32) + labels = np.array(data['fine_labels']) + assert images.shape == (50000, 3, 32, 32) and images.dtype == np.uint8 + assert labels.shape == (50000,) and labels.dtype == np.int32 + assert np.min(images) == 0 and np.max(images) == 255 + assert np.min(labels) == 0 and np.max(labels) == 99 + onehot = np.zeros((labels.size, np.max(labels) + 1), dtype=np.float32) + onehot[np.arange(labels.size), labels] = 1.0 + + with TFRecordExporter(tfrecord_dir, images.shape[0]) as tfr: + order = tfr.choose_shuffled_order() + for idx in range(order.size): + tfr.add_image(images[order[idx]]) + tfr.add_labels(onehot[order]) + +#---------------------------------------------------------------------------- + +def create_svhn(tfrecord_dir, svhn_dir): + print('Loading SVHN from "%s"' % svhn_dir) + import pickle + images = [] + labels = [] + for batch in range(1, 4): + with open(os.path.join(svhn_dir, 'train_%d.pkl' % batch), 'rb') as file: + data = pickle.load(file, encoding='latin1') + images.append(data[0]) + labels.append(data[1]) + images = np.concatenate(images) + labels = np.concatenate(labels) + assert images.shape == (73257, 3, 32, 32) and images.dtype == np.uint8 + assert labels.shape == (73257,) and labels.dtype == np.uint8 + assert np.min(images) == 0 and np.max(images) == 255 + assert np.min(labels) == 0 and np.max(labels) == 9 + onehot = np.zeros((labels.size, np.max(labels) + 1), dtype=np.float32) + onehot[np.arange(labels.size), labels] = 1.0 + + with TFRecordExporter(tfrecord_dir, images.shape[0]) as tfr: + order = tfr.choose_shuffled_order() + for idx in range(order.size): + tfr.add_image(images[order[idx]]) + tfr.add_labels(onehot[order]) + +#---------------------------------------------------------------------------- + +def create_lsun(tfrecord_dir, lmdb_dir, resolution=256, max_images=None): + print('Loading LSUN dataset from "%s"' % lmdb_dir) + import lmdb # pip install lmdb # pylint: disable=import-error + import cv2 # pip install opencv-python + import io + with lmdb.open(lmdb_dir, readonly=True).begin(write=False) as txn: + total_images = txn.stat()['entries'] # pylint: disable=no-value-for-parameter + if max_images is None: + max_images = total_images + with TFRecordExporter(tfrecord_dir, max_images) as tfr: + for _idx, (_key, value) in enumerate(txn.cursor()): + try: + try: + img = cv2.imdecode(np.fromstring(value, dtype=np.uint8), 1) + if img is None: + raise IOError('cv2.imdecode failed') + img = img[:, :, ::-1] # BGR => RGB + except IOError: + img = np.asarray(PIL.Image.open(io.BytesIO(value))) + crop = np.min(img.shape[:2]) + img = img[(img.shape[0] - crop) // 2 : (img.shape[0] + crop) // 2, (img.shape[1] - crop) // 2 : (img.shape[1] + crop) // 2] + img = PIL.Image.fromarray(img, 'RGB') + img = img.resize((resolution, resolution), PIL.Image.ANTIALIAS) + img = np.asarray(img) + img = img.transpose([2, 0, 1]) # HWC => CHW + tfr.add_image(img) + except: + print(sys.exc_info()[1]) + if tfr.cur_images == max_images: + break + +#---------------------------------------------------------------------------- + +def create_lsun_wide(tfrecord_dir, lmdb_dir, width=512, height=384, max_images=None): + assert width == 2 ** int(np.round(np.log2(width))) + assert height <= width + print('Loading LSUN dataset from "%s"' % lmdb_dir) + import lmdb # pip install lmdb # pylint: disable=import-error + import cv2 # pip install opencv-python + import io + with lmdb.open(lmdb_dir, readonly=True).begin(write=False) as txn: + total_images = txn.stat()['entries'] # pylint: disable=no-value-for-parameter + if max_images is None: + max_images = total_images + with TFRecordExporter(tfrecord_dir, max_images, print_progress=False) as tfr: + for idx, (_key, value) in enumerate(txn.cursor()): + try: + try: + img = cv2.imdecode(np.fromstring(value, dtype=np.uint8), 1) + if img is None: + raise IOError('cv2.imdecode failed') + img = img[:, :, ::-1] # BGR => RGB + except IOError: + img = np.asarray(PIL.Image.open(io.BytesIO(value))) + + ch = int(np.round(width * img.shape[0] / img.shape[1])) + if img.shape[1] < width or ch < height: + continue + + img = img[(img.shape[0] - ch) // 2 : (img.shape[0] + ch) // 2] + img = PIL.Image.fromarray(img, 'RGB') + img = img.resize((width, height), PIL.Image.ANTIALIAS) + img = np.asarray(img) + img = img.transpose([2, 0, 1]) # HWC => CHW + + canvas = np.zeros([3, width, width], dtype=np.uint8) + canvas[:, (width - height) // 2 : (width + height) // 2] = img + tfr.add_image(canvas) + print('\r%d / %d => %d ' % (idx + 1, total_images, tfr.cur_images), end='') + + except: + print(sys.exc_info()[1]) + if tfr.cur_images == max_images: + break + print() + +#---------------------------------------------------------------------------- + +def create_celeba(tfrecord_dir, celeba_dir, cx=89, cy=121): + print('Loading CelebA from "%s"' % celeba_dir) + glob_pattern = os.path.join(celeba_dir, 'img_align_celeba_png', '*.png') + image_filenames = sorted(glob.glob(glob_pattern)) + expected_images = 202599 + if len(image_filenames) != expected_images: + error('Expected to find %d images' % expected_images) + + with TFRecordExporter(tfrecord_dir, len(image_filenames)) as tfr: + order = tfr.choose_shuffled_order() + for idx in range(order.size): + img = np.asarray(PIL.Image.open(image_filenames[order[idx]])) + assert img.shape == (218, 178, 3) + img = img[cy - 64 : cy + 64, cx - 64 : cx + 64] + img = img.transpose(2, 0, 1) # HWC => CHW + tfr.add_image(img) + +#---------------------------------------------------------------------------- + +def create_from_images(tfrecord_dir, image_dir, shuffle): + print('Loading images from "%s"' % image_dir) + image_filenames = sorted(glob.glob(os.path.join(image_dir, '*'))) + if len(image_filenames) == 0: + error('No input images found') + + img = np.asarray(PIL.Image.open(image_filenames[0])) + resolution = img.shape[0] + channels = img.shape[2] if img.ndim == 3 else 1 + if img.shape[1] != resolution: + error('Input images must have the same width and height') + if resolution != 2 ** int(np.floor(np.log2(resolution))): + error('Input image resolution must be a power-of-two') + if channels not in [1, 3]: + error('Input images must be stored as RGB or grayscale') + + with TFRecordExporter(tfrecord_dir, len(image_filenames)) as tfr: + order = tfr.choose_shuffled_order() if shuffle else np.arange(len(image_filenames)) + for idx in range(order.size): + img = np.asarray(PIL.Image.open(image_filenames[order[idx]])) + if channels == 1: + img = img[np.newaxis, :, :] # HW => CHW + else: + img = img.transpose([2, 0, 1]) # HWC => CHW + tfr.add_image(img) + +#---------------------------------------------------------------------------- + +def create_from_hdf5(tfrecord_dir, hdf5_filename, shuffle): + print('Loading HDF5 archive from "%s"' % hdf5_filename) + import h5py # conda install h5py + with h5py.File(hdf5_filename, 'r') as hdf5_file: + hdf5_data = max([value for key, value in hdf5_file.items() if key.startswith('data')], key=lambda lod: lod.shape[3]) + with TFRecordExporter(tfrecord_dir, hdf5_data.shape[0]) as tfr: + order = tfr.choose_shuffled_order() if shuffle else np.arange(hdf5_data.shape[0]) + for idx in range(order.size): + tfr.add_image(hdf5_data[order[idx]]) + npy_filename = os.path.splitext(hdf5_filename)[0] + '-labels.npy' + if os.path.isfile(npy_filename): + tfr.add_labels(np.load(npy_filename)[order]) + +#---------------------------------------------------------------------------- + +def execute_cmdline(argv): + prog = argv[0] + parser = argparse.ArgumentParser( + prog = prog, + description = 'Tool for creating multi-resolution TFRecords datasets for StyleGAN and ProGAN.', + epilog = 'Type "%s -h" for more information.' % prog) + + subparsers = parser.add_subparsers(dest='command') + subparsers.required = True + def add_command(cmd, desc, example=None): + epilog = 'Example: %s %s' % (prog, example) if example is not None else None + return subparsers.add_parser(cmd, description=desc, help=desc, epilog=epilog) + + p = add_command( 'display', 'Display images in dataset.', + 'display datasets/mnist') + p.add_argument( 'tfrecord_dir', help='Directory containing dataset') + + p = add_command( 'extract', 'Extract images from dataset.', + 'extract datasets/mnist mnist-images') + p.add_argument( 'tfrecord_dir', help='Directory containing dataset') + p.add_argument( 'output_dir', help='Directory to extract the images into') + + p = add_command( 'compare', 'Compare two datasets.', + 'compare datasets/mydataset datasets/mnist') + p.add_argument( 'tfrecord_dir_a', help='Directory containing first dataset') + p.add_argument( 'tfrecord_dir_b', help='Directory containing second dataset') + p.add_argument( '--ignore_labels', help='Ignore labels (default: 0)', type=int, default=0) + + p = add_command( 'create_mnist', 'Create dataset for MNIST.', + 'create_mnist datasets/mnist ~/downloads/mnist') + p.add_argument( 'tfrecord_dir', help='New dataset directory to be created') + p.add_argument( 'mnist_dir', help='Directory containing MNIST') + + p = add_command( 'create_mnistrgb', 'Create dataset for MNIST-RGB.', + 'create_mnistrgb datasets/mnistrgb ~/downloads/mnist') + p.add_argument( 'tfrecord_dir', help='New dataset directory to be created') + p.add_argument( 'mnist_dir', help='Directory containing MNIST') + p.add_argument( '--num_images', help='Number of composite images to create (default: 1000000)', type=int, default=1000000) + p.add_argument( '--random_seed', help='Random seed (default: 123)', type=int, default=123) + + p = add_command( 'create_cifar10', 'Create dataset for CIFAR-10.', + 'create_cifar10 datasets/cifar10 ~/downloads/cifar10') + p.add_argument( 'tfrecord_dir', help='New dataset directory to be created') + p.add_argument( 'cifar10_dir', help='Directory containing CIFAR-10') + + p = add_command( 'create_cifar100', 'Create dataset for CIFAR-100.', + 'create_cifar100 datasets/cifar100 ~/downloads/cifar100') + p.add_argument( 'tfrecord_dir', help='New dataset directory to be created') + p.add_argument( 'cifar100_dir', help='Directory containing CIFAR-100') + + p = add_command( 'create_svhn', 'Create dataset for SVHN.', + 'create_svhn datasets/svhn ~/downloads/svhn') + p.add_argument( 'tfrecord_dir', help='New dataset directory to be created') + p.add_argument( 'svhn_dir', help='Directory containing SVHN') + + p = add_command( 'create_lsun', 'Create dataset for single LSUN category.', + 'create_lsun datasets/lsun-car-100k ~/downloads/lsun/car_lmdb --resolution 256 --max_images 100000') + p.add_argument( 'tfrecord_dir', help='New dataset directory to be created') + p.add_argument( 'lmdb_dir', help='Directory containing LMDB database') + p.add_argument( '--resolution', help='Output resolution (default: 256)', type=int, default=256) + p.add_argument( '--max_images', help='Maximum number of images (default: none)', type=int, default=None) + + p = add_command( 'create_lsun_wide', 'Create LSUN dataset with non-square aspect ratio.', + 'create_lsun_wide datasets/lsun-car-512x384 ~/downloads/lsun/car_lmdb --width 512 --height 384') + p.add_argument( 'tfrecord_dir', help='New dataset directory to be created') + p.add_argument( 'lmdb_dir', help='Directory containing LMDB database') + p.add_argument( '--width', help='Output width (default: 512)', type=int, default=512) + p.add_argument( '--height', help='Output height (default: 384)', type=int, default=384) + p.add_argument( '--max_images', help='Maximum number of images (default: none)', type=int, default=None) + + p = add_command( 'create_celeba', 'Create dataset for CelebA.', + 'create_celeba datasets/celeba ~/downloads/celeba') + p.add_argument( 'tfrecord_dir', help='New dataset directory to be created') + p.add_argument( 'celeba_dir', help='Directory containing CelebA') + p.add_argument( '--cx', help='Center X coordinate (default: 89)', type=int, default=89) + p.add_argument( '--cy', help='Center Y coordinate (default: 121)', type=int, default=121) + + p = add_command( 'create_from_images', 'Create dataset from a directory full of images.', + 'create_from_images datasets/mydataset myimagedir') + p.add_argument( 'tfrecord_dir', help='New dataset directory to be created') + p.add_argument( 'image_dir', help='Directory containing the images') + p.add_argument( '--shuffle', help='Randomize image order (default: 1)', type=int, default=1) + + p = add_command( 'create_from_hdf5', 'Create dataset from legacy HDF5 archive.', + 'create_from_hdf5 datasets/celebahq ~/downloads/celeba-hq-1024x1024.h5') + p.add_argument( 'tfrecord_dir', help='New dataset directory to be created') + p.add_argument( 'hdf5_filename', help='HDF5 archive containing the images') + p.add_argument( '--shuffle', help='Randomize image order (default: 1)', type=int, default=1) + + args = parser.parse_args(argv[1:] if len(argv) > 1 else ['-h']) + func = globals()[args.command] + del args.command + func(**vars(args)) + +#---------------------------------------------------------------------------- + +if __name__ == "__main__": + execute_cmdline(sys.argv) + +#---------------------------------------------------------------------------- diff --git a/models/stylegan/stylegan_tf/dnnlib/__init__.py b/models/stylegan/stylegan_tf/dnnlib/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ad43827d8a279c4a797e09b51b8fd96e8e003ee6 --- /dev/null +++ b/models/stylegan/stylegan_tf/dnnlib/__init__.py @@ -0,0 +1,20 @@ +# Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved. +# +# This work is licensed under the Creative Commons Attribution-NonCommercial +# 4.0 International License. To view a copy of this license, visit +# http://creativecommons.org/licenses/by-nc/4.0/ or send a letter to +# Creative Commons, PO Box 1866, Mountain View, CA 94042, USA. + +from . import submission + +from .submission.run_context import RunContext + +from .submission.submit import SubmitTarget +from .submission.submit import PathType +from .submission.submit import SubmitConfig +from .submission.submit import get_path_from_template +from .submission.submit import submit_run + +from .util import EasyDict + +submit_config: SubmitConfig = None # Package level variable for SubmitConfig which is only valid when inside the run function. diff --git a/models/stylegan/stylegan_tf/dnnlib/util.py b/models/stylegan/stylegan_tf/dnnlib/util.py new file mode 100644 index 0000000000000000000000000000000000000000..133ef764c0707d9384a33f0350ba71b1e624072f --- /dev/null +++ b/models/stylegan/stylegan_tf/dnnlib/util.py @@ -0,0 +1,405 @@ +# Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved. +# +# This work is licensed under the Creative Commons Attribution-NonCommercial +# 4.0 International License. To view a copy of this license, visit +# http://creativecommons.org/licenses/by-nc/4.0/ or send a letter to +# Creative Commons, PO Box 1866, Mountain View, CA 94042, USA. + +"""Miscellaneous utility classes and functions.""" + +import ctypes +import fnmatch +import importlib +import inspect +import numpy as np +import os +import shutil +import sys +import types +import io +import pickle +import re +import requests +import html +import hashlib +import glob +import uuid + +from distutils.util import strtobool +from typing import Any, List, Tuple, Union + + +# Util classes +# ------------------------------------------------------------------------------------------ + + +class EasyDict(dict): + """Convenience class that behaves like a dict but allows access with the attribute syntax.""" + + def __getattr__(self, name: str) -> 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: str) -> None: + """Write text to stdout (and a file) and optionally flush.""" + 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() + + +# 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 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) + return obj.__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) -> bool: + """Determine whether the given object is a valid URL string.""" + if not isinstance(obj, str) or not "://" in obj: + return False + 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) -> Any: + """Download the given URL and return a binary-mode file object to access the data.""" + assert is_url(url) + assert num_attempts >= 1 + + # Lookup from cache. + url_md5 = hashlib.md5(url.encode("utf-8")).hexdigest() + if cache_dir is not None: + cache_files = glob.glob(os.path.join(cache_dir, url_md5 + "_*")) + if len(cache_files) == 1: + return open(cache_files[0], "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 quota exceeded") + + 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: + if not attempts_left: + if verbose: + print(" failed") + raise + if verbose: + print(".", end="", flush=True) + + # Save to cache. + if cache_dir is not None: + 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 + + # Return data as file object. + return io.BytesIO(url_data) diff --git a/models/stylegan/stylegan_tf/generate_figures.py b/models/stylegan/stylegan_tf/generate_figures.py new file mode 100644 index 0000000000000000000000000000000000000000..45b68b86146198c701a66fb8ba7a363d901d6951 --- /dev/null +++ b/models/stylegan/stylegan_tf/generate_figures.py @@ -0,0 +1,161 @@ +# Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved. +# +# This work is licensed under the Creative Commons Attribution-NonCommercial +# 4.0 International License. To view a copy of this license, visit +# http://creativecommons.org/licenses/by-nc/4.0/ or send a letter to +# Creative Commons, PO Box 1866, Mountain View, CA 94042, USA. + +"""Minimal script for reproducing the figures of the StyleGAN paper using pre-trained generators.""" + +import os +import pickle +import numpy as np +import PIL.Image +import dnnlib +import dnnlib.tflib as tflib +import config + +#---------------------------------------------------------------------------- +# Helpers for loading and using pre-trained generators. + +url_ffhq = 'https://drive.google.com/uc?id=1MEGjdvVpUsu1jB4zrXZN7Y4kBBOzizDQ' # karras2019stylegan-ffhq-1024x1024.pkl +url_celebahq = 'https://drive.google.com/uc?id=1MGqJl28pN4t7SAtSrPdSRJSQJqahkzUf' # karras2019stylegan-celebahq-1024x1024.pkl +url_bedrooms = 'https://drive.google.com/uc?id=1MOSKeGF0FJcivpBI7s63V9YHloUTORiF' # karras2019stylegan-bedrooms-256x256.pkl +url_cars = 'https://drive.google.com/uc?id=1MJ6iCfNtMIRicihwRorsM3b7mmtmK9c3' # karras2019stylegan-cars-512x384.pkl +url_cats = 'https://drive.google.com/uc?id=1MQywl0FNt6lHu8E_EUqnRbviagS7fbiJ' # karras2019stylegan-cats-256x256.pkl + +synthesis_kwargs = dict(output_transform=dict(func=tflib.convert_images_to_uint8, nchw_to_nhwc=True), minibatch_size=8) + +_Gs_cache = dict() + +def load_Gs(url): + if url not in _Gs_cache: + with dnnlib.util.open_url(url, cache_dir=config.cache_dir) as f: + _G, _D, Gs = pickle.load(f) + _Gs_cache[url] = Gs + return _Gs_cache[url] + +#---------------------------------------------------------------------------- +# Figures 2, 3, 10, 11, 12: Multi-resolution grid of uncurated result images. + +def draw_uncurated_result_figure(png, Gs, cx, cy, cw, ch, rows, lods, seed): + print(png) + latents = np.random.RandomState(seed).randn(sum(rows * 2**lod for lod in lods), Gs.input_shape[1]) + images = Gs.run(latents, None, **synthesis_kwargs) # [seed, y, x, rgb] + + canvas = PIL.Image.new('RGB', (sum(cw // 2**lod for lod in lods), ch * rows), 'white') + image_iter = iter(list(images)) + for col, lod in enumerate(lods): + for row in range(rows * 2**lod): + image = PIL.Image.fromarray(next(image_iter), 'RGB') + image = image.crop((cx, cy, cx + cw, cy + ch)) + image = image.resize((cw // 2**lod, ch // 2**lod), PIL.Image.ANTIALIAS) + canvas.paste(image, (sum(cw // 2**lod for lod in lods[:col]), row * ch // 2**lod)) + canvas.save(png) + +#---------------------------------------------------------------------------- +# Figure 3: Style mixing. + +def draw_style_mixing_figure(png, Gs, w, h, src_seeds, dst_seeds, style_ranges): + print(png) + src_latents = np.stack(np.random.RandomState(seed).randn(Gs.input_shape[1]) for seed in src_seeds) + dst_latents = np.stack(np.random.RandomState(seed).randn(Gs.input_shape[1]) for seed in dst_seeds) + src_dlatents = Gs.components.mapping.run(src_latents, None) # [seed, layer, component] + dst_dlatents = Gs.components.mapping.run(dst_latents, None) # [seed, layer, component] + src_images = Gs.components.synthesis.run(src_dlatents, randomize_noise=False, **synthesis_kwargs) + dst_images = Gs.components.synthesis.run(dst_dlatents, randomize_noise=False, **synthesis_kwargs) + + canvas = PIL.Image.new('RGB', (w * (len(src_seeds) + 1), h * (len(dst_seeds) + 1)), 'white') + for col, src_image in enumerate(list(src_images)): + canvas.paste(PIL.Image.fromarray(src_image, 'RGB'), ((col + 1) * w, 0)) + for row, dst_image in enumerate(list(dst_images)): + canvas.paste(PIL.Image.fromarray(dst_image, 'RGB'), (0, (row + 1) * h)) + row_dlatents = np.stack([dst_dlatents[row]] * len(src_seeds)) + row_dlatents[:, style_ranges[row]] = src_dlatents[:, style_ranges[row]] + row_images = Gs.components.synthesis.run(row_dlatents, randomize_noise=False, **synthesis_kwargs) + for col, image in enumerate(list(row_images)): + canvas.paste(PIL.Image.fromarray(image, 'RGB'), ((col + 1) * w, (row + 1) * h)) + canvas.save(png) + +#---------------------------------------------------------------------------- +# Figure 4: Noise detail. + +def draw_noise_detail_figure(png, Gs, w, h, num_samples, seeds): + print(png) + canvas = PIL.Image.new('RGB', (w * 3, h * len(seeds)), 'white') + for row, seed in enumerate(seeds): + latents = np.stack([np.random.RandomState(seed).randn(Gs.input_shape[1])] * num_samples) + images = Gs.run(latents, None, truncation_psi=1, **synthesis_kwargs) + canvas.paste(PIL.Image.fromarray(images[0], 'RGB'), (0, row * h)) + for i in range(4): + crop = PIL.Image.fromarray(images[i + 1], 'RGB') + crop = crop.crop((650, 180, 906, 436)) + crop = crop.resize((w//2, h//2), PIL.Image.NEAREST) + canvas.paste(crop, (w + (i%2) * w//2, row * h + (i//2) * h//2)) + diff = np.std(np.mean(images, axis=3), axis=0) * 4 + diff = np.clip(diff + 0.5, 0, 255).astype(np.uint8) + canvas.paste(PIL.Image.fromarray(diff, 'L'), (w * 2, row * h)) + canvas.save(png) + +#---------------------------------------------------------------------------- +# Figure 5: Noise components. + +def draw_noise_components_figure(png, Gs, w, h, seeds, noise_ranges, flips): + print(png) + Gsc = Gs.clone() + noise_vars = [var for name, var in Gsc.components.synthesis.vars.items() if name.startswith('noise')] + noise_pairs = list(zip(noise_vars, tflib.run(noise_vars))) # [(var, val), ...] + latents = np.stack(np.random.RandomState(seed).randn(Gs.input_shape[1]) for seed in seeds) + all_images = [] + for noise_range in noise_ranges: + tflib.set_vars({var: val * (1 if i in noise_range else 0) for i, (var, val) in enumerate(noise_pairs)}) + range_images = Gsc.run(latents, None, truncation_psi=1, randomize_noise=False, **synthesis_kwargs) + range_images[flips, :, :] = range_images[flips, :, ::-1] + all_images.append(list(range_images)) + + canvas = PIL.Image.new('RGB', (w * 2, h * 2), 'white') + for col, col_images in enumerate(zip(*all_images)): + canvas.paste(PIL.Image.fromarray(col_images[0], 'RGB').crop((0, 0, w//2, h)), (col * w, 0)) + canvas.paste(PIL.Image.fromarray(col_images[1], 'RGB').crop((w//2, 0, w, h)), (col * w + w//2, 0)) + canvas.paste(PIL.Image.fromarray(col_images[2], 'RGB').crop((0, 0, w//2, h)), (col * w, h)) + canvas.paste(PIL.Image.fromarray(col_images[3], 'RGB').crop((w//2, 0, w, h)), (col * w + w//2, h)) + canvas.save(png) + +#---------------------------------------------------------------------------- +# Figure 8: Truncation trick. + +def draw_truncation_trick_figure(png, Gs, w, h, seeds, psis): + print(png) + latents = np.stack(np.random.RandomState(seed).randn(Gs.input_shape[1]) for seed in seeds) + dlatents = Gs.components.mapping.run(latents, None) # [seed, layer, component] + dlatent_avg = Gs.get_var('dlatent_avg') # [component] + + canvas = PIL.Image.new('RGB', (w * len(psis), h * len(seeds)), 'white') + for row, dlatent in enumerate(list(dlatents)): + row_dlatents = (dlatent[np.newaxis] - dlatent_avg) * np.reshape(psis, [-1, 1, 1]) + dlatent_avg + row_images = Gs.components.synthesis.run(row_dlatents, randomize_noise=False, **synthesis_kwargs) + for col, image in enumerate(list(row_images)): + canvas.paste(PIL.Image.fromarray(image, 'RGB'), (col * w, row * h)) + canvas.save(png) + +#---------------------------------------------------------------------------- +# Main program. + +def main(): + tflib.init_tf() + os.makedirs(config.result_dir, exist_ok=True) + draw_uncurated_result_figure(os.path.join(config.result_dir, 'figure02-uncurated-ffhq.png'), load_Gs(url_ffhq), cx=0, cy=0, cw=1024, ch=1024, rows=3, lods=[0,1,2,2,3,3], seed=5) + draw_style_mixing_figure(os.path.join(config.result_dir, 'figure03-style-mixing.png'), load_Gs(url_ffhq), w=1024, h=1024, src_seeds=[639,701,687,615,2268], dst_seeds=[888,829,1898,1733,1614,845], style_ranges=[range(0,4)]*3+[range(4,8)]*2+[range(8,18)]) + draw_noise_detail_figure(os.path.join(config.result_dir, 'figure04-noise-detail.png'), load_Gs(url_ffhq), w=1024, h=1024, num_samples=100, seeds=[1157,1012]) + draw_noise_components_figure(os.path.join(config.result_dir, 'figure05-noise-components.png'), load_Gs(url_ffhq), w=1024, h=1024, seeds=[1967,1555], noise_ranges=[range(0, 18), range(0, 0), range(8, 18), range(0, 8)], flips=[1]) + draw_truncation_trick_figure(os.path.join(config.result_dir, 'figure08-truncation-trick.png'), load_Gs(url_ffhq), w=1024, h=1024, seeds=[91,388], psis=[1, 0.7, 0.5, 0, -0.5, -1]) + draw_uncurated_result_figure(os.path.join(config.result_dir, 'figure10-uncurated-bedrooms.png'), load_Gs(url_bedrooms), cx=0, cy=0, cw=256, ch=256, rows=5, lods=[0,0,1,1,2,2,2], seed=0) + draw_uncurated_result_figure(os.path.join(config.result_dir, 'figure11-uncurated-cars.png'), load_Gs(url_cars), cx=0, cy=64, cw=512, ch=384, rows=4, lods=[0,1,2,2,3,3], seed=2) + draw_uncurated_result_figure(os.path.join(config.result_dir, 'figure12-uncurated-cats.png'), load_Gs(url_cats), cx=0, cy=0, cw=256, ch=256, rows=5, lods=[0,0,1,1,2,2,2], seed=1) + +#---------------------------------------------------------------------------- + +if __name__ == "__main__": + main() + +#---------------------------------------------------------------------------- diff --git a/models/stylegan/stylegan_tf/metrics/frechet_inception_distance.py b/models/stylegan/stylegan_tf/metrics/frechet_inception_distance.py new file mode 100644 index 0000000000000000000000000000000000000000..41f71fe4bfb85218cc283b3f7bc3a34fea5f790d --- /dev/null +++ b/models/stylegan/stylegan_tf/metrics/frechet_inception_distance.py @@ -0,0 +1,72 @@ +# Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved. +# +# This work is licensed under the Creative Commons Attribution-NonCommercial +# 4.0 International License. To view a copy of this license, visit +# http://creativecommons.org/licenses/by-nc/4.0/ or send a letter to +# Creative Commons, PO Box 1866, Mountain View, CA 94042, USA. + +"""Frechet Inception Distance (FID).""" + +import os +import numpy as np +import scipy +import tensorflow as tf +import dnnlib.tflib as tflib + +from metrics import metric_base +from training import misc + +#---------------------------------------------------------------------------- + +class FID(metric_base.MetricBase): + def __init__(self, num_images, minibatch_per_gpu, **kwargs): + super().__init__(**kwargs) + self.num_images = num_images + self.minibatch_per_gpu = minibatch_per_gpu + + def _evaluate(self, Gs, num_gpus): + minibatch_size = num_gpus * self.minibatch_per_gpu + inception = misc.load_pkl('https://drive.google.com/uc?id=1MzTY44rLToO5APn8TZmfR7_ENSe5aZUn') # inception_v3_features.pkl + activations = np.empty([self.num_images, inception.output_shape[1]], dtype=np.float32) + + # Calculate statistics for reals. + cache_file = self._get_cache_file_for_reals(num_images=self.num_images) + os.makedirs(os.path.dirname(cache_file), exist_ok=True) + if os.path.isfile(cache_file): + mu_real, sigma_real = misc.load_pkl(cache_file) + else: + for idx, images in enumerate(self._iterate_reals(minibatch_size=minibatch_size)): + begin = idx * minibatch_size + end = min(begin + minibatch_size, self.num_images) + activations[begin:end] = inception.run(images[:end-begin], num_gpus=num_gpus, assume_frozen=True) + if end == self.num_images: + break + mu_real = np.mean(activations, axis=0) + sigma_real = np.cov(activations, rowvar=False) + misc.save_pkl((mu_real, sigma_real), cache_file) + + # Construct TensorFlow graph. + result_expr = [] + for gpu_idx in range(num_gpus): + with tf.device('/gpu:%d' % gpu_idx): + Gs_clone = Gs.clone() + inception_clone = inception.clone() + latents = tf.random_normal([self.minibatch_per_gpu] + Gs_clone.input_shape[1:]) + images = Gs_clone.get_output_for(latents, None, is_validation=True, randomize_noise=True) + images = tflib.convert_images_to_uint8(images) + result_expr.append(inception_clone.get_output_for(images)) + + # Calculate statistics for fakes. + for begin in range(0, self.num_images, minibatch_size): + end = min(begin + minibatch_size, self.num_images) + activations[begin:end] = np.concatenate(tflib.run(result_expr), axis=0)[:end-begin] + mu_fake = np.mean(activations, axis=0) + sigma_fake = np.cov(activations, rowvar=False) + + # Calculate FID. + m = np.square(mu_fake - mu_real).sum() + s, _ = scipy.linalg.sqrtm(np.dot(sigma_fake, sigma_real), disp=False) # pylint: disable=no-member + dist = m + np.trace(sigma_fake + sigma_real - 2*s) + self._report_result(np.real(dist)) + +#---------------------------------------------------------------------------- diff --git a/models/stylegan/stylegan_tf/metrics/linear_separability.py b/models/stylegan/stylegan_tf/metrics/linear_separability.py new file mode 100644 index 0000000000000000000000000000000000000000..e50be5a0fea00eba7af2d05cccf74bacedbea1c3 --- /dev/null +++ b/models/stylegan/stylegan_tf/metrics/linear_separability.py @@ -0,0 +1,177 @@ +# Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved. +# +# This work is licensed under the Creative Commons Attribution-NonCommercial +# 4.0 International License. To view a copy of this license, visit +# http://creativecommons.org/licenses/by-nc/4.0/ or send a letter to +# Creative Commons, PO Box 1866, Mountain View, CA 94042, USA. + +"""Linear Separability (LS).""" + +from collections import defaultdict +import numpy as np +import sklearn.svm +import tensorflow as tf +import dnnlib.tflib as tflib + +from metrics import metric_base +from training import misc + +#---------------------------------------------------------------------------- + +classifier_urls = [ + 'https://drive.google.com/uc?id=1Q5-AI6TwWhCVM7Muu4tBM7rp5nG_gmCX', # celebahq-classifier-00-male.pkl + 'https://drive.google.com/uc?id=1Q5c6HE__ReW2W8qYAXpao68V1ryuisGo', # celebahq-classifier-01-smiling.pkl + 'https://drive.google.com/uc?id=1Q7738mgWTljPOJQrZtSMLxzShEhrvVsU', # celebahq-classifier-02-attractive.pkl + 'https://drive.google.com/uc?id=1QBv2Mxe7ZLvOv1YBTLq-T4DS3HjmXV0o', # celebahq-classifier-03-wavy-hair.pkl + 'https://drive.google.com/uc?id=1QIvKTrkYpUrdA45nf7pspwAqXDwWOLhV', # celebahq-classifier-04-young.pkl + 'https://drive.google.com/uc?id=1QJPH5rW7MbIjFUdZT7vRYfyUjNYDl4_L', # celebahq-classifier-05-5-o-clock-shadow.pkl + 'https://drive.google.com/uc?id=1QPZXSYf6cptQnApWS_T83sqFMun3rULY', # celebahq-classifier-06-arched-eyebrows.pkl + 'https://drive.google.com/uc?id=1QPgoAZRqINXk_PFoQ6NwMmiJfxc5d2Pg', # celebahq-classifier-07-bags-under-eyes.pkl + 'https://drive.google.com/uc?id=1QQPQgxgI6wrMWNyxFyTLSgMVZmRr1oO7', # celebahq-classifier-08-bald.pkl + 'https://drive.google.com/uc?id=1QcSphAmV62UrCIqhMGgcIlZfoe8hfWaF', # celebahq-classifier-09-bangs.pkl + 'https://drive.google.com/uc?id=1QdWTVwljClTFrrrcZnPuPOR4mEuz7jGh', # celebahq-classifier-10-big-lips.pkl + 'https://drive.google.com/uc?id=1QgvEWEtr2mS4yj1b_Y3WKe6cLWL3LYmK', # celebahq-classifier-11-big-nose.pkl + 'https://drive.google.com/uc?id=1QidfMk9FOKgmUUIziTCeo8t-kTGwcT18', # celebahq-classifier-12-black-hair.pkl + 'https://drive.google.com/uc?id=1QthrJt-wY31GPtV8SbnZQZ0_UEdhasHO', # celebahq-classifier-13-blond-hair.pkl + 'https://drive.google.com/uc?id=1QvCAkXxdYT4sIwCzYDnCL9Nb5TDYUxGW', # celebahq-classifier-14-blurry.pkl + 'https://drive.google.com/uc?id=1QvLWuwSuWI9Ln8cpxSGHIciUsnmaw8L0', # celebahq-classifier-15-brown-hair.pkl + 'https://drive.google.com/uc?id=1QxW6THPI2fqDoiFEMaV6pWWHhKI_OoA7', # celebahq-classifier-16-bushy-eyebrows.pkl + 'https://drive.google.com/uc?id=1R71xKw8oTW2IHyqmRDChhTBkW9wq4N9v', # celebahq-classifier-17-chubby.pkl + 'https://drive.google.com/uc?id=1RDn_fiLfEGbTc7JjazRXuAxJpr-4Pl67', # celebahq-classifier-18-double-chin.pkl + 'https://drive.google.com/uc?id=1RGBuwXbaz5052bM4VFvaSJaqNvVM4_cI', # celebahq-classifier-19-eyeglasses.pkl + 'https://drive.google.com/uc?id=1RIxOiWxDpUwhB-9HzDkbkLegkd7euRU9', # celebahq-classifier-20-goatee.pkl + 'https://drive.google.com/uc?id=1RPaNiEnJODdr-fwXhUFdoSQLFFZC7rC-', # celebahq-classifier-21-gray-hair.pkl + 'https://drive.google.com/uc?id=1RQH8lPSwOI2K_9XQCZ2Ktz7xm46o80ep', # celebahq-classifier-22-heavy-makeup.pkl + 'https://drive.google.com/uc?id=1RXZM61xCzlwUZKq-X7QhxOg0D2telPow', # celebahq-classifier-23-high-cheekbones.pkl + 'https://drive.google.com/uc?id=1RgASVHW8EWMyOCiRb5fsUijFu-HfxONM', # celebahq-classifier-24-mouth-slightly-open.pkl + 'https://drive.google.com/uc?id=1RkC8JLqLosWMaRne3DARRgolhbtg_wnr', # celebahq-classifier-25-mustache.pkl + 'https://drive.google.com/uc?id=1RqtbtFT2EuwpGTqsTYJDyXdnDsFCPtLO', # celebahq-classifier-26-narrow-eyes.pkl + 'https://drive.google.com/uc?id=1Rs7hU-re8bBMeRHR-fKgMbjPh-RIbrsh', # celebahq-classifier-27-no-beard.pkl + 'https://drive.google.com/uc?id=1RynDJQWdGOAGffmkPVCrLJqy_fciPF9E', # celebahq-classifier-28-oval-face.pkl + 'https://drive.google.com/uc?id=1S0TZ_Hdv5cb06NDaCD8NqVfKy7MuXZsN', # celebahq-classifier-29-pale-skin.pkl + 'https://drive.google.com/uc?id=1S3JPhZH2B4gVZZYCWkxoRP11q09PjCkA', # celebahq-classifier-30-pointy-nose.pkl + 'https://drive.google.com/uc?id=1S3pQuUz-Jiywq_euhsfezWfGkfzLZ87W', # celebahq-classifier-31-receding-hairline.pkl + 'https://drive.google.com/uc?id=1S6nyIl_SEI3M4l748xEdTV2vymB_-lrY', # celebahq-classifier-32-rosy-cheeks.pkl + 'https://drive.google.com/uc?id=1S9P5WCi3GYIBPVYiPTWygrYIUSIKGxbU', # celebahq-classifier-33-sideburns.pkl + 'https://drive.google.com/uc?id=1SANviG-pp08n7AFpE9wrARzozPIlbfCH', # celebahq-classifier-34-straight-hair.pkl + 'https://drive.google.com/uc?id=1SArgyMl6_z7P7coAuArqUC2zbmckecEY', # celebahq-classifier-35-wearing-earrings.pkl + 'https://drive.google.com/uc?id=1SC5JjS5J-J4zXFO9Vk2ZU2DT82TZUza_', # celebahq-classifier-36-wearing-hat.pkl + 'https://drive.google.com/uc?id=1SDAQWz03HGiu0MSOKyn7gvrp3wdIGoj-', # celebahq-classifier-37-wearing-lipstick.pkl + 'https://drive.google.com/uc?id=1SEtrVK-TQUC0XeGkBE9y7L8VXfbchyKX', # celebahq-classifier-38-wearing-necklace.pkl + 'https://drive.google.com/uc?id=1SF_mJIdyGINXoV-I6IAxHB_k5dxiF6M-', # celebahq-classifier-39-wearing-necktie.pkl +] + +#---------------------------------------------------------------------------- + +def prob_normalize(p): + p = np.asarray(p).astype(np.float32) + assert len(p.shape) == 2 + return p / np.sum(p) + +def mutual_information(p): + p = prob_normalize(p) + px = np.sum(p, axis=1) + py = np.sum(p, axis=0) + result = 0.0 + for x in range(p.shape[0]): + p_x = px[x] + for y in range(p.shape[1]): + p_xy = p[x][y] + p_y = py[y] + if p_xy > 0.0: + result += p_xy * np.log2(p_xy / (p_x * p_y)) # get bits as output + return result + +def entropy(p): + p = prob_normalize(p) + result = 0.0 + for x in range(p.shape[0]): + for y in range(p.shape[1]): + p_xy = p[x][y] + if p_xy > 0.0: + result -= p_xy * np.log2(p_xy) + return result + +def conditional_entropy(p): + # H(Y|X) where X corresponds to axis 0, Y to axis 1 + # i.e., How many bits of additional information are needed to where we are on axis 1 if we know where we are on axis 0? + p = prob_normalize(p) + y = np.sum(p, axis=0, keepdims=True) # marginalize to calculate H(Y) + return max(0.0, entropy(y) - mutual_information(p)) # can slip just below 0 due to FP inaccuracies, clean those up. + +#---------------------------------------------------------------------------- + +class LS(metric_base.MetricBase): + def __init__(self, num_samples, num_keep, attrib_indices, minibatch_per_gpu, **kwargs): + assert num_keep <= num_samples + super().__init__(**kwargs) + self.num_samples = num_samples + self.num_keep = num_keep + self.attrib_indices = attrib_indices + self.minibatch_per_gpu = minibatch_per_gpu + + def _evaluate(self, Gs, num_gpus): + minibatch_size = num_gpus * self.minibatch_per_gpu + + # Construct TensorFlow graph for each GPU. + result_expr = [] + for gpu_idx in range(num_gpus): + with tf.device('/gpu:%d' % gpu_idx): + Gs_clone = Gs.clone() + + # Generate images. + latents = tf.random_normal([self.minibatch_per_gpu] + Gs_clone.input_shape[1:]) + dlatents = Gs_clone.components.mapping.get_output_for(latents, None, is_validation=True) + images = Gs_clone.components.synthesis.get_output_for(dlatents, is_validation=True, randomize_noise=True) + + # Downsample to 256x256. The attribute classifiers were built for 256x256. + if images.shape[2] > 256: + factor = images.shape[2] // 256 + images = tf.reshape(images, [-1, images.shape[1], images.shape[2] // factor, factor, images.shape[3] // factor, factor]) + images = tf.reduce_mean(images, axis=[3, 5]) + + # Run classifier for each attribute. + result_dict = dict(latents=latents, dlatents=dlatents[:,-1]) + for attrib_idx in self.attrib_indices: + classifier = misc.load_pkl(classifier_urls[attrib_idx]) + logits = classifier.get_output_for(images, None) + predictions = tf.nn.softmax(tf.concat([logits, -logits], axis=1)) + result_dict[attrib_idx] = predictions + result_expr.append(result_dict) + + # Sampling loop. + results = [] + for _ in range(0, self.num_samples, minibatch_size): + results += tflib.run(result_expr) + results = {key: np.concatenate([value[key] for value in results], axis=0) for key in results[0].keys()} + + # Calculate conditional entropy for each attribute. + conditional_entropies = defaultdict(list) + for attrib_idx in self.attrib_indices: + # Prune the least confident samples. + pruned_indices = list(range(self.num_samples)) + pruned_indices = sorted(pruned_indices, key=lambda i: -np.max(results[attrib_idx][i])) + pruned_indices = pruned_indices[:self.num_keep] + + # Fit SVM to the remaining samples. + svm_targets = np.argmax(results[attrib_idx][pruned_indices], axis=1) + for space in ['latents', 'dlatents']: + svm_inputs = results[space][pruned_indices] + try: + svm = sklearn.svm.LinearSVC() + svm.fit(svm_inputs, svm_targets) + svm.score(svm_inputs, svm_targets) + svm_outputs = svm.predict(svm_inputs) + except: + svm_outputs = svm_targets # assume perfect prediction + + # Calculate conditional entropy. + p = [[np.mean([case == (row, col) for case in zip(svm_outputs, svm_targets)]) for col in (0, 1)] for row in (0, 1)] + conditional_entropies[space].append(conditional_entropy(p)) + + # Calculate separability scores. + scores = {key: 2**np.sum(values) for key, values in conditional_entropies.items()} + self._report_result(scores['latents'], suffix='_z') + self._report_result(scores['dlatents'], suffix='_w') + +#---------------------------------------------------------------------------- diff --git a/models/stylegan/stylegan_tf/metrics/metric_base.py b/models/stylegan/stylegan_tf/metrics/metric_base.py new file mode 100644 index 0000000000000000000000000000000000000000..0db82adecb60260393eaf82bd991575d79085787 --- /dev/null +++ b/models/stylegan/stylegan_tf/metrics/metric_base.py @@ -0,0 +1,142 @@ +# Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved. +# +# This work is licensed under the Creative Commons Attribution-NonCommercial +# 4.0 International License. To view a copy of this license, visit +# http://creativecommons.org/licenses/by-nc/4.0/ or send a letter to +# Creative Commons, PO Box 1866, Mountain View, CA 94042, USA. + +"""Common definitions for GAN metrics.""" + +import os +import time +import hashlib +import numpy as np +import tensorflow as tf +import dnnlib +import dnnlib.tflib as tflib + +import config +from training import misc +from training import dataset + +#---------------------------------------------------------------------------- +# Standard metrics. + +fid50k = dnnlib.EasyDict(func_name='metrics.frechet_inception_distance.FID', name='fid50k', num_images=50000, minibatch_per_gpu=8) +ppl_zfull = dnnlib.EasyDict(func_name='metrics.perceptual_path_length.PPL', name='ppl_zfull', num_samples=100000, epsilon=1e-4, space='z', sampling='full', minibatch_per_gpu=16) +ppl_wfull = dnnlib.EasyDict(func_name='metrics.perceptual_path_length.PPL', name='ppl_wfull', num_samples=100000, epsilon=1e-4, space='w', sampling='full', minibatch_per_gpu=16) +ppl_zend = dnnlib.EasyDict(func_name='metrics.perceptual_path_length.PPL', name='ppl_zend', num_samples=100000, epsilon=1e-4, space='z', sampling='end', minibatch_per_gpu=16) +ppl_wend = dnnlib.EasyDict(func_name='metrics.perceptual_path_length.PPL', name='ppl_wend', num_samples=100000, epsilon=1e-4, space='w', sampling='end', minibatch_per_gpu=16) +ls = dnnlib.EasyDict(func_name='metrics.linear_separability.LS', name='ls', num_samples=200000, num_keep=100000, attrib_indices=range(40), minibatch_per_gpu=4) +dummy = dnnlib.EasyDict(func_name='metrics.metric_base.DummyMetric', name='dummy') # for debugging + +#---------------------------------------------------------------------------- +# Base class for metrics. + +class MetricBase: + def __init__(self, name): + self.name = name + self._network_pkl = None + self._dataset_args = None + self._mirror_augment = None + self._results = [] + self._eval_time = None + + def run(self, network_pkl, run_dir=None, dataset_args=None, mirror_augment=None, num_gpus=1, tf_config=None, log_results=True): + self._network_pkl = network_pkl + self._dataset_args = dataset_args + self._mirror_augment = mirror_augment + self._results = [] + + if (dataset_args is None or mirror_augment is None) and run_dir is not None: + run_config = misc.parse_config_for_previous_run(run_dir) + self._dataset_args = dict(run_config['dataset']) + self._dataset_args['shuffle_mb'] = 0 + self._mirror_augment = run_config['train'].get('mirror_augment', False) + + time_begin = time.time() + with tf.Graph().as_default(), tflib.create_session(tf_config).as_default(): # pylint: disable=not-context-manager + _G, _D, Gs = misc.load_pkl(self._network_pkl) + self._evaluate(Gs, num_gpus=num_gpus) + self._eval_time = time.time() - time_begin + + if log_results: + result_str = self.get_result_str() + if run_dir is not None: + log = os.path.join(run_dir, 'metric-%s.txt' % self.name) + with dnnlib.util.Logger(log, 'a'): + print(result_str) + else: + print(result_str) + + def get_result_str(self): + network_name = os.path.splitext(os.path.basename(self._network_pkl))[0] + if len(network_name) > 29: + network_name = '...' + network_name[-26:] + result_str = '%-30s' % network_name + result_str += ' time %-12s' % dnnlib.util.format_time(self._eval_time) + for res in self._results: + result_str += ' ' + self.name + res.suffix + ' ' + result_str += res.fmt % res.value + return result_str + + def update_autosummaries(self): + for res in self._results: + tflib.autosummary.autosummary('Metrics/' + self.name + res.suffix, res.value) + + def _evaluate(self, Gs, num_gpus): + raise NotImplementedError # to be overridden by subclasses + + def _report_result(self, value, suffix='', fmt='%-10.4f'): + self._results += [dnnlib.EasyDict(value=value, suffix=suffix, fmt=fmt)] + + def _get_cache_file_for_reals(self, extension='pkl', **kwargs): + all_args = dnnlib.EasyDict(metric_name=self.name, mirror_augment=self._mirror_augment) + all_args.update(self._dataset_args) + all_args.update(kwargs) + md5 = hashlib.md5(repr(sorted(all_args.items())).encode('utf-8')) + dataset_name = self._dataset_args['tfrecord_dir'].replace('\\', '/').split('/')[-1] + return os.path.join(config.cache_dir, '%s-%s-%s.%s' % (md5.hexdigest(), self.name, dataset_name, extension)) + + def _iterate_reals(self, minibatch_size): + dataset_obj = dataset.load_dataset(data_dir=config.data_dir, **self._dataset_args) + while True: + images, _labels = dataset_obj.get_minibatch_np(minibatch_size) + if self._mirror_augment: + images = misc.apply_mirror_augment(images) + yield images + + def _iterate_fakes(self, Gs, minibatch_size, num_gpus): + while True: + latents = np.random.randn(minibatch_size, *Gs.input_shape[1:]) + fmt = dict(func=tflib.convert_images_to_uint8, nchw_to_nhwc=True) + images = Gs.run(latents, None, output_transform=fmt, is_validation=True, num_gpus=num_gpus, assume_frozen=True) + yield images + +#---------------------------------------------------------------------------- +# Group of multiple metrics. + +class MetricGroup: + def __init__(self, metric_kwarg_list): + self.metrics = [dnnlib.util.call_func_by_name(**kwargs) for kwargs in metric_kwarg_list] + + def run(self, *args, **kwargs): + for metric in self.metrics: + metric.run(*args, **kwargs) + + def get_result_str(self): + return ' '.join(metric.get_result_str() for metric in self.metrics) + + def update_autosummaries(self): + for metric in self.metrics: + metric.update_autosummaries() + +#---------------------------------------------------------------------------- +# Dummy metric for debugging purposes. + +class DummyMetric(MetricBase): + def _evaluate(self, Gs, num_gpus): + _ = Gs, num_gpus + self._report_result(0.0) + +#---------------------------------------------------------------------------- diff --git a/models/stylegan/stylegan_tf/pretrained_example.py b/models/stylegan/stylegan_tf/pretrained_example.py new file mode 100644 index 0000000000000000000000000000000000000000..63baef08bfa4bf34f52a0cf63e10a0b6783ac316 --- /dev/null +++ b/models/stylegan/stylegan_tf/pretrained_example.py @@ -0,0 +1,47 @@ +# Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved. +# +# This work is licensed under the Creative Commons Attribution-NonCommercial +# 4.0 International License. To view a copy of this license, visit +# http://creativecommons.org/licenses/by-nc/4.0/ or send a letter to +# Creative Commons, PO Box 1866, Mountain View, CA 94042, USA. + +"""Minimal script for generating an image using pre-trained StyleGAN generator.""" + +import os +import pickle +import numpy as np +import PIL.Image +import dnnlib +import dnnlib.tflib as tflib +import config + +def main(): + # Initialize TensorFlow. + tflib.init_tf() + + # Load pre-trained network. + url = 'https://drive.google.com/uc?id=1MEGjdvVpUsu1jB4zrXZN7Y4kBBOzizDQ' # karras2019stylegan-ffhq-1024x1024.pkl + with dnnlib.util.open_url(url, cache_dir=config.cache_dir) as f: + _G, _D, Gs = pickle.load(f) + # _G = Instantaneous snapshot of the generator. Mainly useful for resuming a previous training run. + # _D = Instantaneous snapshot of the discriminator. Mainly useful for resuming a previous training run. + # Gs = Long-term average of the generator. Yields higher-quality results than the instantaneous snapshot. + + # Print network details. + Gs.print_layers() + + # Pick latent vector. + rnd = np.random.RandomState(5) + latents = rnd.randn(1, Gs.input_shape[1]) + + # Generate image. + fmt = dict(func=tflib.convert_images_to_uint8, nchw_to_nhwc=True) + images = Gs.run(latents, None, truncation_psi=0.7, randomize_noise=True, output_transform=fmt) + + # Save image. + os.makedirs(config.result_dir, exist_ok=True) + png_filename = os.path.join(config.result_dir, 'example.png') + PIL.Image.fromarray(images[0], 'RGB').save(png_filename) + +if __name__ == "__main__": + main() diff --git a/models/stylegan/stylegan_tf/run_metrics.py b/models/stylegan/stylegan_tf/run_metrics.py new file mode 100644 index 0000000000000000000000000000000000000000..5d1597bbd4e16a2535309ea74c3559cae2a5fa53 --- /dev/null +++ b/models/stylegan/stylegan_tf/run_metrics.py @@ -0,0 +1,105 @@ +# Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved. +# +# This work is licensed under the Creative Commons Attribution-NonCommercial +# 4.0 International License. To view a copy of this license, visit +# http://creativecommons.org/licenses/by-nc/4.0/ or send a letter to +# Creative Commons, PO Box 1866, Mountain View, CA 94042, USA. + +"""Main entry point for training StyleGAN and ProGAN networks.""" + +import dnnlib +from dnnlib import EasyDict +import dnnlib.tflib as tflib + +import config +from metrics import metric_base +from training import misc + +#---------------------------------------------------------------------------- + +def run_pickle(submit_config, metric_args, network_pkl, dataset_args, mirror_augment): + ctx = dnnlib.RunContext(submit_config) + tflib.init_tf() + print('Evaluating %s metric on network_pkl "%s"...' % (metric_args.name, network_pkl)) + metric = dnnlib.util.call_func_by_name(**metric_args) + print() + metric.run(network_pkl, dataset_args=dataset_args, mirror_augment=mirror_augment, num_gpus=submit_config.num_gpus) + print() + ctx.close() + +#---------------------------------------------------------------------------- + +def run_snapshot(submit_config, metric_args, run_id, snapshot): + ctx = dnnlib.RunContext(submit_config) + tflib.init_tf() + print('Evaluating %s metric on run_id %s, snapshot %s...' % (metric_args.name, run_id, snapshot)) + run_dir = misc.locate_run_dir(run_id) + network_pkl = misc.locate_network_pkl(run_dir, snapshot) + metric = dnnlib.util.call_func_by_name(**metric_args) + print() + metric.run(network_pkl, run_dir=run_dir, num_gpus=submit_config.num_gpus) + print() + ctx.close() + +#---------------------------------------------------------------------------- + +def run_all_snapshots(submit_config, metric_args, run_id): + ctx = dnnlib.RunContext(submit_config) + tflib.init_tf() + print('Evaluating %s metric on all snapshots of run_id %s...' % (metric_args.name, run_id)) + run_dir = misc.locate_run_dir(run_id) + network_pkls = misc.list_network_pkls(run_dir) + metric = dnnlib.util.call_func_by_name(**metric_args) + print() + for idx, network_pkl in enumerate(network_pkls): + ctx.update('', idx, len(network_pkls)) + metric.run(network_pkl, run_dir=run_dir, num_gpus=submit_config.num_gpus) + print() + ctx.close() + +#---------------------------------------------------------------------------- + +def main(): + submit_config = dnnlib.SubmitConfig() + + # Which metrics to evaluate? + metrics = [] + metrics += [metric_base.fid50k] + #metrics += [metric_base.ppl_zfull] + #metrics += [metric_base.ppl_wfull] + #metrics += [metric_base.ppl_zend] + #metrics += [metric_base.ppl_wend] + #metrics += [metric_base.ls] + #metrics += [metric_base.dummy] + + # Which networks to evaluate them on? + tasks = [] + tasks += [EasyDict(run_func_name='run_metrics.run_pickle', network_pkl='https://drive.google.com/uc?id=1MEGjdvVpUsu1jB4zrXZN7Y4kBBOzizDQ', dataset_args=EasyDict(tfrecord_dir='ffhq', shuffle_mb=0), mirror_augment=True)] # karras2019stylegan-ffhq-1024x1024.pkl + #tasks += [EasyDict(run_func_name='run_metrics.run_snapshot', run_id=100, snapshot=25000)] + #tasks += [EasyDict(run_func_name='run_metrics.run_all_snapshots', run_id=100)] + + # How many GPUs to use? + submit_config.num_gpus = 1 + #submit_config.num_gpus = 2 + #submit_config.num_gpus = 4 + #submit_config.num_gpus = 8 + + # Execute. + submit_config.run_dir_root = dnnlib.submission.submit.get_template_from_path(config.result_dir) + submit_config.run_dir_ignore += config.run_dir_ignore + for task in tasks: + for metric in metrics: + submit_config.run_desc = '%s-%s' % (task.run_func_name, metric.name) + if task.run_func_name.endswith('run_snapshot'): + submit_config.run_desc += '-%s-%s' % (task.run_id, task.snapshot) + if task.run_func_name.endswith('run_all_snapshots'): + submit_config.run_desc += '-%s' % task.run_id + submit_config.run_desc += '-%dgpu' % submit_config.num_gpus + dnnlib.submit_run(submit_config, metric_args=metric, **task) + +#---------------------------------------------------------------------------- + +if __name__ == "__main__": + main() + +#---------------------------------------------------------------------------- diff --git a/models/stylegan/stylegan_tf/stylegan-teaser.png b/models/stylegan/stylegan_tf/stylegan-teaser.png new file mode 100644 index 0000000000000000000000000000000000000000..66c9c60092941f3d192f38b0f080510c0772fc02 --- /dev/null +++ b/models/stylegan/stylegan_tf/stylegan-teaser.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:505fa8b7d269bc8c39355b12404a4cf7e53523eda2837f8756f6b4a725e6ccbd +size 1635753 diff --git a/models/stylegan/stylegan_tf/train.py b/models/stylegan/stylegan_tf/train.py new file mode 100644 index 0000000000000000000000000000000000000000..29df3c226b87816ceec25752293df08a70d63189 --- /dev/null +++ b/models/stylegan/stylegan_tf/train.py @@ -0,0 +1,192 @@ +# Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved. +# +# This work is licensed under the Creative Commons Attribution-NonCommercial +# 4.0 International License. To view a copy of this license, visit +# http://creativecommons.org/licenses/by-nc/4.0/ or send a letter to +# Creative Commons, PO Box 1866, Mountain View, CA 94042, USA. + +"""Main entry point for training StyleGAN and ProGAN networks.""" + +import copy +import dnnlib +from dnnlib import EasyDict + +import config +from metrics import metric_base + +#---------------------------------------------------------------------------- +# Official training configs for StyleGAN, targeted mainly for FFHQ. + +if 1: + desc = 'sgan' # Description string included in result subdir name. + train = EasyDict(run_func_name='training.training_loop.training_loop') # Options for training loop. + G = EasyDict(func_name='training.networks_stylegan.G_style') # Options for generator network. + D = EasyDict(func_name='training.networks_stylegan.D_basic') # Options for discriminator network. + G_opt = EasyDict(beta1=0.0, beta2=0.99, epsilon=1e-8) # Options for generator optimizer. + D_opt = EasyDict(beta1=0.0, beta2=0.99, epsilon=1e-8) # Options for discriminator optimizer. + G_loss = EasyDict(func_name='training.loss.G_logistic_nonsaturating') # Options for generator loss. + D_loss = EasyDict(func_name='training.loss.D_logistic_simplegp', r1_gamma=10.0) # Options for discriminator loss. + dataset = EasyDict() # Options for load_dataset(). + sched = EasyDict() # Options for TrainingSchedule. + grid = EasyDict(size='4k', layout='random') # Options for setup_snapshot_image_grid(). + metrics = [metric_base.fid50k] # Options for MetricGroup. + submit_config = dnnlib.SubmitConfig() # Options for dnnlib.submit_run(). + tf_config = {'rnd.np_random_seed': 1000} # Options for tflib.init_tf(). + + # Dataset. + desc += '-ffhq'; dataset = EasyDict(tfrecord_dir='ffhq'); train.mirror_augment = True + #desc += '-ffhq512'; dataset = EasyDict(tfrecord_dir='ffhq', resolution=512); train.mirror_augment = True + #desc += '-ffhq256'; dataset = EasyDict(tfrecord_dir='ffhq', resolution=256); train.mirror_augment = True + #desc += '-celebahq'; dataset = EasyDict(tfrecord_dir='celebahq'); train.mirror_augment = True + #desc += '-bedroom'; dataset = EasyDict(tfrecord_dir='lsun-bedroom-full'); train.mirror_augment = False + #desc += '-car'; dataset = EasyDict(tfrecord_dir='lsun-car-512x384'); train.mirror_augment = False + #desc += '-cat'; dataset = EasyDict(tfrecord_dir='lsun-cat-full'); train.mirror_augment = False + + # Number of GPUs. + #desc += '-1gpu'; submit_config.num_gpus = 1; sched.minibatch_base = 4; sched.minibatch_dict = {4: 128, 8: 128, 16: 128, 32: 64, 64: 32, 128: 16, 256: 8, 512: 4} + #desc += '-2gpu'; submit_config.num_gpus = 2; sched.minibatch_base = 8; sched.minibatch_dict = {4: 256, 8: 256, 16: 128, 32: 64, 64: 32, 128: 16, 256: 8} + #desc += '-4gpu'; submit_config.num_gpus = 4; sched.minibatch_base = 16; sched.minibatch_dict = {4: 512, 8: 256, 16: 128, 32: 64, 64: 32, 128: 16} + desc += '-8gpu'; submit_config.num_gpus = 8; sched.minibatch_base = 32; sched.minibatch_dict = {4: 512, 8: 256, 16: 128, 32: 64, 64: 32} + + # Default options. + train.total_kimg = 25000 + sched.lod_initial_resolution = 8 + sched.G_lrate_dict = {128: 0.0015, 256: 0.002, 512: 0.003, 1024: 0.003} + sched.D_lrate_dict = EasyDict(sched.G_lrate_dict) + + # WGAN-GP loss for CelebA-HQ. + #desc += '-wgangp'; G_loss = EasyDict(func_name='training.loss.G_wgan'); D_loss = EasyDict(func_name='training.loss.D_wgan_gp'); sched.G_lrate_dict = {k: min(v, 0.002) for k, v in sched.G_lrate_dict.items()}; sched.D_lrate_dict = EasyDict(sched.G_lrate_dict) + + # Table 1. + #desc += '-tuned-baseline'; G.use_styles = False; G.use_pixel_norm = True; G.use_instance_norm = False; G.mapping_layers = 0; G.truncation_psi = None; G.const_input_layer = False; G.style_mixing_prob = 0.0; G.use_noise = False + #desc += '-add-mapping-and-styles'; G.const_input_layer = False; G.style_mixing_prob = 0.0; G.use_noise = False + #desc += '-remove-traditional-input'; G.style_mixing_prob = 0.0; G.use_noise = False + #desc += '-add-noise-inputs'; G.style_mixing_prob = 0.0 + #desc += '-mixing-regularization' # default + + # Table 2. + #desc += '-mix0'; G.style_mixing_prob = 0.0 + #desc += '-mix50'; G.style_mixing_prob = 0.5 + #desc += '-mix90'; G.style_mixing_prob = 0.9 # default + #desc += '-mix100'; G.style_mixing_prob = 1.0 + + # Table 4. + #desc += '-traditional-0'; G.use_styles = False; G.use_pixel_norm = True; G.use_instance_norm = False; G.mapping_layers = 0; G.truncation_psi = None; G.const_input_layer = False; G.style_mixing_prob = 0.0; G.use_noise = False + #desc += '-traditional-8'; G.use_styles = False; G.use_pixel_norm = True; G.use_instance_norm = False; G.mapping_layers = 8; G.truncation_psi = None; G.const_input_layer = False; G.style_mixing_prob = 0.0; G.use_noise = False + #desc += '-stylebased-0'; G.mapping_layers = 0 + #desc += '-stylebased-1'; G.mapping_layers = 1 + #desc += '-stylebased-2'; G.mapping_layers = 2 + #desc += '-stylebased-8'; G.mapping_layers = 8 # default + +#---------------------------------------------------------------------------- +# Official training configs for Progressive GAN, targeted mainly for CelebA-HQ. + +if 0: + desc = 'pgan' # Description string included in result subdir name. + train = EasyDict(run_func_name='training.training_loop.training_loop') # Options for training loop. + G = EasyDict(func_name='training.networks_progan.G_paper') # Options for generator network. + D = EasyDict(func_name='training.networks_progan.D_paper') # Options for discriminator network. + G_opt = EasyDict(beta1=0.0, beta2=0.99, epsilon=1e-8) # Options for generator optimizer. + D_opt = EasyDict(beta1=0.0, beta2=0.99, epsilon=1e-8) # Options for discriminator optimizer. + G_loss = EasyDict(func_name='training.loss.G_wgan') # Options for generator loss. + D_loss = EasyDict(func_name='training.loss.D_wgan_gp') # Options for discriminator loss. + dataset = EasyDict() # Options for load_dataset(). + sched = EasyDict() # Options for TrainingSchedule. + grid = EasyDict(size='1080p', layout='random') # Options for setup_snapshot_image_grid(). + metrics = [metric_base.fid50k] # Options for MetricGroup. + submit_config = dnnlib.SubmitConfig() # Options for dnnlib.submit_run(). + tf_config = {'rnd.np_random_seed': 1000} # Options for tflib.init_tf(). + + # Dataset (choose one). + desc += '-celebahq'; dataset = EasyDict(tfrecord_dir='celebahq'); train.mirror_augment = True + #desc += '-celeba'; dataset = EasyDict(tfrecord_dir='celeba'); train.mirror_augment = True + #desc += '-cifar10'; dataset = EasyDict(tfrecord_dir='cifar10') + #desc += '-cifar100'; dataset = EasyDict(tfrecord_dir='cifar100') + #desc += '-svhn'; dataset = EasyDict(tfrecord_dir='svhn') + #desc += '-mnist'; dataset = EasyDict(tfrecord_dir='mnist') + #desc += '-mnistrgb'; dataset = EasyDict(tfrecord_dir='mnistrgb') + #desc += '-syn1024rgb'; dataset = EasyDict(class_name='training.dataset.SyntheticDataset', resolution=1024, num_channels=3) + #desc += '-lsun-airplane'; dataset = EasyDict(tfrecord_dir='lsun-airplane-100k'); train.mirror_augment = True + #desc += '-lsun-bedroom'; dataset = EasyDict(tfrecord_dir='lsun-bedroom-100k'); train.mirror_augment = True + #desc += '-lsun-bicycle'; dataset = EasyDict(tfrecord_dir='lsun-bicycle-100k'); train.mirror_augment = True + #desc += '-lsun-bird'; dataset = EasyDict(tfrecord_dir='lsun-bird-100k'); train.mirror_augment = True + #desc += '-lsun-boat'; dataset = EasyDict(tfrecord_dir='lsun-boat-100k'); train.mirror_augment = True + #desc += '-lsun-bottle'; dataset = EasyDict(tfrecord_dir='lsun-bottle-100k'); train.mirror_augment = True + #desc += '-lsun-bridge'; dataset = EasyDict(tfrecord_dir='lsun-bridge-100k'); train.mirror_augment = True + #desc += '-lsun-bus'; dataset = EasyDict(tfrecord_dir='lsun-bus-100k'); train.mirror_augment = True + #desc += '-lsun-car'; dataset = EasyDict(tfrecord_dir='lsun-car-100k'); train.mirror_augment = True + #desc += '-lsun-cat'; dataset = EasyDict(tfrecord_dir='lsun-cat-100k'); train.mirror_augment = True + #desc += '-lsun-chair'; dataset = EasyDict(tfrecord_dir='lsun-chair-100k'); train.mirror_augment = True + #desc += '-lsun-churchoutdoor'; dataset = EasyDict(tfrecord_dir='lsun-churchoutdoor-100k'); train.mirror_augment = True + #desc += '-lsun-classroom'; dataset = EasyDict(tfrecord_dir='lsun-classroom-100k'); train.mirror_augment = True + #desc += '-lsun-conferenceroom'; dataset = EasyDict(tfrecord_dir='lsun-conferenceroom-100k'); train.mirror_augment = True + #desc += '-lsun-cow'; dataset = EasyDict(tfrecord_dir='lsun-cow-100k'); train.mirror_augment = True + #desc += '-lsun-diningroom'; dataset = EasyDict(tfrecord_dir='lsun-diningroom-100k'); train.mirror_augment = True + #desc += '-lsun-diningtable'; dataset = EasyDict(tfrecord_dir='lsun-diningtable-100k'); train.mirror_augment = True + #desc += '-lsun-dog'; dataset = EasyDict(tfrecord_dir='lsun-dog-100k'); train.mirror_augment = True + #desc += '-lsun-horse'; dataset = EasyDict(tfrecord_dir='lsun-horse-100k'); train.mirror_augment = True + #desc += '-lsun-kitchen'; dataset = EasyDict(tfrecord_dir='lsun-kitchen-100k'); train.mirror_augment = True + #desc += '-lsun-livingroom'; dataset = EasyDict(tfrecord_dir='lsun-livingroom-100k'); train.mirror_augment = True + #desc += '-lsun-motorbike'; dataset = EasyDict(tfrecord_dir='lsun-motorbike-100k'); train.mirror_augment = True + #desc += '-lsun-person'; dataset = EasyDict(tfrecord_dir='lsun-person-100k'); train.mirror_augment = True + #desc += '-lsun-pottedplant'; dataset = EasyDict(tfrecord_dir='lsun-pottedplant-100k'); train.mirror_augment = True + #desc += '-lsun-restaurant'; dataset = EasyDict(tfrecord_dir='lsun-restaurant-100k'); train.mirror_augment = True + #desc += '-lsun-sheep'; dataset = EasyDict(tfrecord_dir='lsun-sheep-100k'); train.mirror_augment = True + #desc += '-lsun-sofa'; dataset = EasyDict(tfrecord_dir='lsun-sofa-100k'); train.mirror_augment = True + #desc += '-lsun-tower'; dataset = EasyDict(tfrecord_dir='lsun-tower-100k'); train.mirror_augment = True + #desc += '-lsun-train'; dataset = EasyDict(tfrecord_dir='lsun-train-100k'); train.mirror_augment = True + #desc += '-lsun-tvmonitor'; dataset = EasyDict(tfrecord_dir='lsun-tvmonitor-100k'); train.mirror_augment = True + + # Conditioning & snapshot options. + #desc += '-cond'; dataset.max_label_size = 'full' # conditioned on full label + #desc += '-cond1'; dataset.max_label_size = 1 # conditioned on first component of the label + #desc += '-g4k'; grid.size = '4k' + #desc += '-grpc'; grid.layout = 'row_per_class' + + # Config presets (choose one). + #desc += '-preset-v1-1gpu'; submit_config.num_gpus = 1; D.mbstd_group_size = 16; sched.minibatch_base = 16; sched.minibatch_dict = {256: 14, 512: 6, 1024: 3}; sched.lod_training_kimg = 800; sched.lod_transition_kimg = 800; train.total_kimg = 19000 + desc += '-preset-v2-1gpu'; submit_config.num_gpus = 1; sched.minibatch_base = 4; sched.minibatch_dict = {4: 128, 8: 128, 16: 128, 32: 64, 64: 32, 128: 16, 256: 8, 512: 4}; sched.G_lrate_dict = {1024: 0.0015}; sched.D_lrate_dict = EasyDict(sched.G_lrate_dict); train.total_kimg = 12000 + #desc += '-preset-v2-2gpus'; submit_config.num_gpus = 2; sched.minibatch_base = 8; sched.minibatch_dict = {4: 256, 8: 256, 16: 128, 32: 64, 64: 32, 128: 16, 256: 8}; sched.G_lrate_dict = {512: 0.0015, 1024: 0.002}; sched.D_lrate_dict = EasyDict(sched.G_lrate_dict); train.total_kimg = 12000 + #desc += '-preset-v2-4gpus'; submit_config.num_gpus = 4; sched.minibatch_base = 16; sched.minibatch_dict = {4: 512, 8: 256, 16: 128, 32: 64, 64: 32, 128: 16}; sched.G_lrate_dict = {256: 0.0015, 512: 0.002, 1024: 0.003}; sched.D_lrate_dict = EasyDict(sched.G_lrate_dict); train.total_kimg = 12000 + #desc += '-preset-v2-8gpus'; submit_config.num_gpus = 8; sched.minibatch_base = 32; sched.minibatch_dict = {4: 512, 8: 256, 16: 128, 32: 64, 64: 32}; sched.G_lrate_dict = {128: 0.0015, 256: 0.002, 512: 0.003, 1024: 0.003}; sched.D_lrate_dict = EasyDict(sched.G_lrate_dict); train.total_kimg = 12000 + + # Numerical precision (choose one). + desc += '-fp32'; sched.max_minibatch_per_gpu = {256: 16, 512: 8, 1024: 4} + #desc += '-fp16'; G.dtype = 'float16'; D.dtype = 'float16'; G.pixelnorm_epsilon=1e-4; G_opt.use_loss_scaling = True; D_opt.use_loss_scaling = True; sched.max_minibatch_per_gpu = {512: 16, 1024: 8} + + # Disable individual features. + #desc += '-nogrowing'; sched.lod_initial_resolution = 1024; sched.lod_training_kimg = 0; sched.lod_transition_kimg = 0; train.total_kimg = 10000 + #desc += '-nopixelnorm'; G.use_pixelnorm = False + #desc += '-nowscale'; G.use_wscale = False; D.use_wscale = False + #desc += '-noleakyrelu'; G.use_leakyrelu = False + #desc += '-nosmoothing'; train.G_smoothing_kimg = 0.0 + #desc += '-norepeat'; train.minibatch_repeats = 1 + #desc += '-noreset'; train.reset_opt_for_new_lod = False + + # Special modes. + #desc += '-BENCHMARK'; sched.lod_initial_resolution = 4; sched.lod_training_kimg = 3; sched.lod_transition_kimg = 3; train.total_kimg = (8*2+1)*3; sched.tick_kimg_base = 1; sched.tick_kimg_dict = {}; train.image_snapshot_ticks = 1000; train.network_snapshot_ticks = 1000 + #desc += '-BENCHMARK0'; sched.lod_initial_resolution = 1024; train.total_kimg = 10; sched.tick_kimg_base = 1; sched.tick_kimg_dict = {}; train.image_snapshot_ticks = 1000; train.network_snapshot_ticks = 1000 + #desc += '-VERBOSE'; sched.tick_kimg_base = 1; sched.tick_kimg_dict = {}; train.image_snapshot_ticks = 1; train.network_snapshot_ticks = 100 + #desc += '-GRAPH'; train.save_tf_graph = True + #desc += '-HIST'; train.save_weight_histograms = True + +#---------------------------------------------------------------------------- +# Main entry point for training. +# Calls the function indicated by 'train' using the selected options. + +def main(): + kwargs = EasyDict(train) + kwargs.update(G_args=G, D_args=D, G_opt_args=G_opt, D_opt_args=D_opt, G_loss_args=G_loss, D_loss_args=D_loss) + kwargs.update(dataset_args=dataset, sched_args=sched, grid_args=grid, metric_arg_list=metrics, tf_config=tf_config) + kwargs.submit_config = copy.deepcopy(submit_config) + kwargs.submit_config.run_dir_root = dnnlib.submission.submit.get_template_from_path(config.result_dir) + kwargs.submit_config.run_dir_ignore += config.run_dir_ignore + kwargs.submit_config.run_desc = desc + dnnlib.submit_run(**kwargs) + +#---------------------------------------------------------------------------- + +if __name__ == "__main__": + main() + +#---------------------------------------------------------------------------- diff --git a/models/stylegan/stylegan_tf/training/training_loop.py b/models/stylegan/stylegan_tf/training/training_loop.py new file mode 100644 index 0000000000000000000000000000000000000000..d9ccb45b1a0321f1d938efa6a62229ffe396dcfe --- /dev/null +++ b/models/stylegan/stylegan_tf/training/training_loop.py @@ -0,0 +1,278 @@ +# Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved. +# +# This work is licensed under the Creative Commons Attribution-NonCommercial +# 4.0 International License. To view a copy of this license, visit +# http://creativecommons.org/licenses/by-nc/4.0/ or send a letter to +# Creative Commons, PO Box 1866, Mountain View, CA 94042, USA. + +"""Main training script.""" + +import os +import numpy as np +import tensorflow as tf +import dnnlib +import dnnlib.tflib as tflib +from dnnlib.tflib.autosummary import autosummary + +import config +import train +from training import dataset +from training import misc +from metrics import metric_base + +#---------------------------------------------------------------------------- +# Just-in-time processing of training images before feeding them to the networks. + +def process_reals(x, lod, mirror_augment, drange_data, drange_net): + with tf.name_scope('ProcessReals'): + with tf.name_scope('DynamicRange'): + x = tf.cast(x, tf.float32) + x = misc.adjust_dynamic_range(x, drange_data, drange_net) + if mirror_augment: + with tf.name_scope('MirrorAugment'): + s = tf.shape(x) + mask = tf.random_uniform([s[0], 1, 1, 1], 0.0, 1.0) + mask = tf.tile(mask, [1, s[1], s[2], s[3]]) + x = tf.where(mask < 0.5, x, tf.reverse(x, axis=[3])) + with tf.name_scope('FadeLOD'): # Smooth crossfade between consecutive levels-of-detail. + s = tf.shape(x) + y = tf.reshape(x, [-1, s[1], s[2]//2, 2, s[3]//2, 2]) + y = tf.reduce_mean(y, axis=[3, 5], keepdims=True) + y = tf.tile(y, [1, 1, 1, 2, 1, 2]) + y = tf.reshape(y, [-1, s[1], s[2], s[3]]) + x = tflib.lerp(x, y, lod - tf.floor(lod)) + with tf.name_scope('UpscaleLOD'): # Upscale to match the expected input/output size of the networks. + s = tf.shape(x) + factor = tf.cast(2 ** tf.floor(lod), tf.int32) + x = tf.reshape(x, [-1, s[1], s[2], 1, s[3], 1]) + x = tf.tile(x, [1, 1, 1, factor, 1, factor]) + x = tf.reshape(x, [-1, s[1], s[2] * factor, s[3] * factor]) + return x + +#---------------------------------------------------------------------------- +# Evaluate time-varying training parameters. + +def training_schedule( + cur_nimg, + training_set, + num_gpus, + lod_initial_resolution = 4, # Image resolution used at the beginning. + lod_training_kimg = 600, # Thousands of real images to show before doubling the resolution. + lod_transition_kimg = 600, # Thousands of real images to show when fading in new layers. + minibatch_base = 16, # Maximum minibatch size, divided evenly among GPUs. + minibatch_dict = {}, # Resolution-specific overrides. + max_minibatch_per_gpu = {}, # Resolution-specific maximum minibatch size per GPU. + G_lrate_base = 0.001, # Learning rate for the generator. + G_lrate_dict = {}, # Resolution-specific overrides. + D_lrate_base = 0.001, # Learning rate for the discriminator. + D_lrate_dict = {}, # Resolution-specific overrides. + lrate_rampup_kimg = 0, # Duration of learning rate ramp-up. + tick_kimg_base = 160, # Default interval of progress snapshots. + tick_kimg_dict = {4: 160, 8:140, 16:120, 32:100, 64:80, 128:60, 256:40, 512:30, 1024:20}): # Resolution-specific overrides. + + # Initialize result dict. + s = dnnlib.EasyDict() + s.kimg = cur_nimg / 1000.0 + + # Training phase. + phase_dur = lod_training_kimg + lod_transition_kimg + phase_idx = int(np.floor(s.kimg / phase_dur)) if phase_dur > 0 else 0 + phase_kimg = s.kimg - phase_idx * phase_dur + + # Level-of-detail and resolution. + s.lod = training_set.resolution_log2 + s.lod -= np.floor(np.log2(lod_initial_resolution)) + s.lod -= phase_idx + if lod_transition_kimg > 0: + s.lod -= max(phase_kimg - lod_training_kimg, 0.0) / lod_transition_kimg + s.lod = max(s.lod, 0.0) + s.resolution = 2 ** (training_set.resolution_log2 - int(np.floor(s.lod))) + + # Minibatch size. + s.minibatch = minibatch_dict.get(s.resolution, minibatch_base) + s.minibatch -= s.minibatch % num_gpus + if s.resolution in max_minibatch_per_gpu: + s.minibatch = min(s.minibatch, max_minibatch_per_gpu[s.resolution] * num_gpus) + + # Learning rate. + s.G_lrate = G_lrate_dict.get(s.resolution, G_lrate_base) + s.D_lrate = D_lrate_dict.get(s.resolution, D_lrate_base) + if lrate_rampup_kimg > 0: + rampup = min(s.kimg / lrate_rampup_kimg, 1.0) + s.G_lrate *= rampup + s.D_lrate *= rampup + + # Other parameters. + s.tick_kimg = tick_kimg_dict.get(s.resolution, tick_kimg_base) + return s + +#---------------------------------------------------------------------------- +# Main training script. + +def training_loop( + submit_config, + G_args = {}, # Options for generator network. + D_args = {}, # Options for discriminator network. + G_opt_args = {}, # Options for generator optimizer. + D_opt_args = {}, # Options for discriminator optimizer. + G_loss_args = {}, # Options for generator loss. + D_loss_args = {}, # Options for discriminator loss. + dataset_args = {}, # Options for dataset.load_dataset(). + sched_args = {}, # Options for train.TrainingSchedule. + grid_args = {}, # Options for train.setup_snapshot_image_grid(). + metric_arg_list = [], # Options for MetricGroup. + tf_config = {}, # Options for tflib.init_tf(). + G_smoothing_kimg = 10.0, # Half-life of the running average of generator weights. + D_repeats = 1, # How many times the discriminator is trained per G iteration. + minibatch_repeats = 4, # Number of minibatches to run before adjusting training parameters. + reset_opt_for_new_lod = True, # Reset optimizer internal state (e.g. Adam moments) when new layers are introduced? + total_kimg = 15000, # Total length of the training, measured in thousands of real images. + mirror_augment = False, # Enable mirror augment? + drange_net = [-1,1], # Dynamic range used when feeding image data to the networks. + image_snapshot_ticks = 1, # How often to export image snapshots? + network_snapshot_ticks = 10, # How often to export network snapshots? + save_tf_graph = False, # Include full TensorFlow computation graph in the tfevents file? + save_weight_histograms = False, # Include weight histograms in the tfevents file? + resume_run_id = None, # Run ID or network pkl to resume training from, None = start from scratch. + resume_snapshot = None, # Snapshot index to resume training from, None = autodetect. + resume_kimg = 0.0, # Assumed training progress at the beginning. Affects reporting and training schedule. + resume_time = 0.0): # Assumed wallclock time at the beginning. Affects reporting. + + # Initialize dnnlib and TensorFlow. + ctx = dnnlib.RunContext(submit_config, train) + tflib.init_tf(tf_config) + + # Load training set. + training_set = dataset.load_dataset(data_dir=config.data_dir, verbose=True, **dataset_args) + + # Construct networks. + with tf.device('/gpu:0'): + if resume_run_id is not None: + network_pkl = misc.locate_network_pkl(resume_run_id, resume_snapshot) + print('Loading networks from "%s"...' % network_pkl) + G, D, Gs = misc.load_pkl(network_pkl) + else: + print('Constructing networks...') + G = tflib.Network('G', num_channels=training_set.shape[0], resolution=training_set.shape[1], label_size=training_set.label_size, **G_args) + D = tflib.Network('D', num_channels=training_set.shape[0], resolution=training_set.shape[1], label_size=training_set.label_size, **D_args) + Gs = G.clone('Gs') + G.print_layers(); D.print_layers() + + print('Building TensorFlow graph...') + with tf.name_scope('Inputs'), tf.device('/cpu:0'): + lod_in = tf.placeholder(tf.float32, name='lod_in', shape=[]) + lrate_in = tf.placeholder(tf.float32, name='lrate_in', shape=[]) + minibatch_in = tf.placeholder(tf.int32, name='minibatch_in', shape=[]) + minibatch_split = minibatch_in // submit_config.num_gpus + Gs_beta = 0.5 ** tf.div(tf.cast(minibatch_in, tf.float32), G_smoothing_kimg * 1000.0) if G_smoothing_kimg > 0.0 else 0.0 + + G_opt = tflib.Optimizer(name='TrainG', learning_rate=lrate_in, **G_opt_args) + D_opt = tflib.Optimizer(name='TrainD', learning_rate=lrate_in, **D_opt_args) + for gpu in range(submit_config.num_gpus): + with tf.name_scope('GPU%d' % gpu), tf.device('/gpu:%d' % gpu): + G_gpu = G if gpu == 0 else G.clone(G.name + '_shadow') + D_gpu = D if gpu == 0 else D.clone(D.name + '_shadow') + lod_assign_ops = [tf.assign(G_gpu.find_var('lod'), lod_in), tf.assign(D_gpu.find_var('lod'), lod_in)] + reals, labels = training_set.get_minibatch_tf() + reals = process_reals(reals, lod_in, mirror_augment, training_set.dynamic_range, drange_net) + with tf.name_scope('G_loss'), tf.control_dependencies(lod_assign_ops): + G_loss = dnnlib.util.call_func_by_name(G=G_gpu, D=D_gpu, opt=G_opt, training_set=training_set, minibatch_size=minibatch_split, **G_loss_args) + with tf.name_scope('D_loss'), tf.control_dependencies(lod_assign_ops): + D_loss = dnnlib.util.call_func_by_name(G=G_gpu, D=D_gpu, opt=D_opt, training_set=training_set, minibatch_size=minibatch_split, reals=reals, labels=labels, **D_loss_args) + G_opt.register_gradients(tf.reduce_mean(G_loss), G_gpu.trainables) + D_opt.register_gradients(tf.reduce_mean(D_loss), D_gpu.trainables) + G_train_op = G_opt.apply_updates() + D_train_op = D_opt.apply_updates() + + Gs_update_op = Gs.setup_as_moving_average_of(G, beta=Gs_beta) + with tf.device('/gpu:0'): + try: + peak_gpu_mem_op = tf.contrib.memory_stats.MaxBytesInUse() + except tf.errors.NotFoundError: + peak_gpu_mem_op = tf.constant(0) + + print('Setting up snapshot image grid...') + grid_size, grid_reals, grid_labels, grid_latents = misc.setup_snapshot_image_grid(G, training_set, **grid_args) + sched = training_schedule(cur_nimg=total_kimg*1000, training_set=training_set, num_gpus=submit_config.num_gpus, **sched_args) + grid_fakes = Gs.run(grid_latents, grid_labels, is_validation=True, minibatch_size=sched.minibatch//submit_config.num_gpus) + + print('Setting up run dir...') + misc.save_image_grid(grid_reals, os.path.join(submit_config.run_dir, 'reals.png'), drange=training_set.dynamic_range, grid_size=grid_size) + misc.save_image_grid(grid_fakes, os.path.join(submit_config.run_dir, 'fakes%06d.png' % resume_kimg), drange=drange_net, grid_size=grid_size) + summary_log = tf.summary.FileWriter(submit_config.run_dir) + if save_tf_graph: + summary_log.add_graph(tf.get_default_graph()) + if save_weight_histograms: + G.setup_weight_histograms(); D.setup_weight_histograms() + metrics = metric_base.MetricGroup(metric_arg_list) + + print('Training...\n') + ctx.update('', cur_epoch=resume_kimg, max_epoch=total_kimg) + maintenance_time = ctx.get_last_update_interval() + cur_nimg = int(resume_kimg * 1000) + cur_tick = 0 + tick_start_nimg = cur_nimg + prev_lod = -1.0 + while cur_nimg < total_kimg * 1000: + if ctx.should_stop(): break + + # Choose training parameters and configure training ops. + sched = training_schedule(cur_nimg=cur_nimg, training_set=training_set, num_gpus=submit_config.num_gpus, **sched_args) + training_set.configure(sched.minibatch // submit_config.num_gpus, sched.lod) + if reset_opt_for_new_lod: + if np.floor(sched.lod) != np.floor(prev_lod) or np.ceil(sched.lod) != np.ceil(prev_lod): + G_opt.reset_optimizer_state(); D_opt.reset_optimizer_state() + prev_lod = sched.lod + + # Run training ops. + for _mb_repeat in range(minibatch_repeats): + for _D_repeat in range(D_repeats): + tflib.run([D_train_op, Gs_update_op], {lod_in: sched.lod, lrate_in: sched.D_lrate, minibatch_in: sched.minibatch}) + cur_nimg += sched.minibatch + tflib.run([G_train_op], {lod_in: sched.lod, lrate_in: sched.G_lrate, minibatch_in: sched.minibatch}) + + # Perform maintenance tasks once per tick. + done = (cur_nimg >= total_kimg * 1000) + if cur_nimg >= tick_start_nimg + sched.tick_kimg * 1000 or done: + cur_tick += 1 + tick_kimg = (cur_nimg - tick_start_nimg) / 1000.0 + tick_start_nimg = cur_nimg + tick_time = ctx.get_time_since_last_update() + total_time = ctx.get_time_since_start() + resume_time + + # Report progress. + print('tick %-5d kimg %-8.1f lod %-5.2f minibatch %-4d time %-12s sec/tick %-7.1f sec/kimg %-7.2f maintenance %-6.1f gpumem %-4.1f' % ( + autosummary('Progress/tick', cur_tick), + autosummary('Progress/kimg', cur_nimg / 1000.0), + autosummary('Progress/lod', sched.lod), + autosummary('Progress/minibatch', sched.minibatch), + dnnlib.util.format_time(autosummary('Timing/total_sec', total_time)), + autosummary('Timing/sec_per_tick', tick_time), + autosummary('Timing/sec_per_kimg', tick_time / tick_kimg), + autosummary('Timing/maintenance_sec', maintenance_time), + autosummary('Resources/peak_gpu_mem_gb', peak_gpu_mem_op.eval() / 2**30))) + autosummary('Timing/total_hours', total_time / (60.0 * 60.0)) + autosummary('Timing/total_days', total_time / (24.0 * 60.0 * 60.0)) + + # Save snapshots. + if cur_tick % image_snapshot_ticks == 0 or done: + grid_fakes = Gs.run(grid_latents, grid_labels, is_validation=True, minibatch_size=sched.minibatch//submit_config.num_gpus) + misc.save_image_grid(grid_fakes, os.path.join(submit_config.run_dir, 'fakes%06d.png' % (cur_nimg // 1000)), drange=drange_net, grid_size=grid_size) + if cur_tick % network_snapshot_ticks == 0 or done or cur_tick == 1: + pkl = os.path.join(submit_config.run_dir, 'network-snapshot-%06d.pkl' % (cur_nimg // 1000)) + misc.save_pkl((G, D, Gs), pkl) + metrics.run(pkl, run_dir=submit_config.run_dir, num_gpus=submit_config.num_gpus, tf_config=tf_config) + + # Update summaries and RunContext. + metrics.update_autosummaries() + tflib.autosummary.save_summaries(summary_log, cur_nimg) + ctx.update('%.2f' % sched.lod, cur_epoch=cur_nimg // 1000, max_epoch=total_kimg) + maintenance_time = ctx.get_last_update_interval() - tick_time + + # Write final results. + misc.save_pkl((G, D, Gs), os.path.join(submit_config.run_dir, 'network-final.pkl')) + summary_log.close() + + ctx.close() + +#---------------------------------------------------------------------------- diff --git a/models/stylegan2/__init__.py b/models/stylegan2/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..87739d5c18fe051149018f275983ebf6380c8b54 --- /dev/null +++ b/models/stylegan2/__init__.py @@ -0,0 +1,16 @@ +import sys +import os +import shutil +import glob +import platform +from pathlib import Path + +current_path = os.getcwd() + +module_path = Path(__file__).parent / 'stylegan2-pytorch' +sys.path.append(str(module_path.resolve())) +os.chdir(module_path) + +from model import Generator + +os.chdir(current_path) \ No newline at end of file diff --git a/models/stylegan2/__pycache__/__init__.cpython-310.pyc b/models/stylegan2/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7fb48bed039c4aecfbd9225cf396b795aae99a35 Binary files /dev/null and b/models/stylegan2/__pycache__/__init__.cpython-310.pyc differ diff --git a/models/stylegan2/stylegan2-pytorch/.gitignore b/models/stylegan2/stylegan2-pytorch/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..b8e449f3ff8a4951e8122cefa463ce506b590246 --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/.gitignore @@ -0,0 +1,133 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +pip-wheel-metadata/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +.python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +wandb/ +*.lmdb/ +*.pkl diff --git a/models/stylegan2/stylegan2-pytorch/LICENSE b/models/stylegan2/stylegan2-pytorch/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..915ca760bc639695e152e784d9dc2dbf71369b67 --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2019 Kim Seonghyeon + +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/models/stylegan2/stylegan2-pytorch/LICENSE-FID b/models/stylegan2/stylegan2-pytorch/LICENSE-FID new file mode 100644 index 0000000000000000000000000000000000000000..261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64 --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/LICENSE-FID @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/models/stylegan2/stylegan2-pytorch/LICENSE-LPIPS b/models/stylegan2/stylegan2-pytorch/LICENSE-LPIPS new file mode 100644 index 0000000000000000000000000000000000000000..e269c6bdc77eecf327fd72b156b7ec3b6434066c --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/LICENSE-LPIPS @@ -0,0 +1,24 @@ +Copyright (c) 2018, Richard Zhang, Phillip Isola, Alexei A. Efros, Eli Shechtman, Oliver Wang +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + diff --git a/models/stylegan2/stylegan2-pytorch/LICENSE-NVIDIA b/models/stylegan2/stylegan2-pytorch/LICENSE-NVIDIA new file mode 100644 index 0000000000000000000000000000000000000000..288fb3247529fc0d19ee2040c29adc65886d9426 --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/LICENSE-NVIDIA @@ -0,0 +1,101 @@ +Copyright (c) 2019, NVIDIA Corporation. All rights reserved. + + +Nvidia Source Code License-NC + +======================================================================= + +1. Definitions + +"Licensor" means any person or entity that distributes its Work. + +"Software" means the original work of authorship made available under +this License. + +"Work" means the Software and any additions to or derivative works of +the Software that are made available under this License. + +"Nvidia Processors" means any central processing unit (CPU), graphics +processing unit (GPU), field-programmable gate array (FPGA), +application-specific integrated circuit (ASIC) or any combination +thereof designed, made, sold, or provided by Nvidia or its affiliates. + +The terms "reproduce," "reproduction," "derivative works," and +"distribution" have the meaning as provided under U.S. copyright law; +provided, however, that for the purposes of this License, derivative +works shall not include works that remain separable from, or merely +link (or bind by name) to the interfaces of, the Work. + +Works, including the Software, are "made available" under this License +by including in or with the Work either (a) a copyright notice +referencing the applicability of this License to the Work, or (b) a +copy of this License. + +2. License Grants + + 2.1 Copyright Grant. Subject to the terms and conditions of this + License, each Licensor grants to you a perpetual, worldwide, + non-exclusive, royalty-free, copyright license to reproduce, + prepare derivative works of, publicly display, publicly perform, + sublicense and distribute its Work and any resulting derivative + works in any form. + +3. Limitations + + 3.1 Redistribution. You may reproduce or distribute the Work only + if (a) you do so under this License, (b) you include a complete + copy of this License with your distribution, and (c) you retain + without modification any copyright, patent, trademark, or + attribution notices that are present in the Work. + + 3.2 Derivative Works. You may specify that additional or different + terms apply to the use, reproduction, and distribution of your + derivative works of the Work ("Your Terms") only if (a) Your Terms + provide that the use limitation in Section 3.3 applies to your + derivative works, and (b) you identify the specific derivative + works that are subject to Your Terms. Notwithstanding Your Terms, + this License (including the redistribution requirements in Section + 3.1) will continue to apply to the Work itself. + + 3.3 Use Limitation. The Work and any derivative works thereof only + may be used or intended for use non-commercially. The Work or + derivative works thereof may be used or intended for use by Nvidia + or its affiliates commercially or non-commercially. As used herein, + "non-commercially" means for research or evaluation purposes only. + + 3.4 Patent Claims. If you bring or threaten to bring a patent claim + against any Licensor (including any claim, cross-claim or + counterclaim in a lawsuit) to enforce any patents that you allege + are infringed by any Work, then your rights under this License from + such Licensor (including the grants in Sections 2.1 and 2.2) will + terminate immediately. + + 3.5 Trademarks. This License does not grant any rights to use any + Licensor's or its affiliates' names, logos, or trademarks, except + as necessary to reproduce the notices described in this License. + + 3.6 Termination. If you violate any term of this License, then your + rights under this License (including the grants in Sections 2.1 and + 2.2) will terminate immediately. + +4. Disclaimer of Warranty. + +THE WORK IS PROVIDED "AS IS" WITHOUT WARRANTIES OR CONDITIONS OF ANY +KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WARRANTIES OR CONDITIONS OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE OR +NON-INFRINGEMENT. YOU BEAR THE RISK OF UNDERTAKING ANY ACTIVITIES UNDER +THIS LICENSE. + +5. Limitation of Liability. + +EXCEPT AS PROHIBITED BY APPLICABLE LAW, IN NO EVENT AND UNDER NO LEGAL +THEORY, WHETHER IN TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE +SHALL ANY LICENSOR BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY DIRECT, +INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF +OR RELATED TO THIS LICENSE, THE USE OR INABILITY TO USE THE WORK +(INCLUDING BUT NOT LIMITED TO LOSS OF GOODWILL, BUSINESS INTERRUPTION, +LOST PROFITS OR DATA, COMPUTER FAILURE OR MALFUNCTION, OR ANY OTHER +COMMERCIAL DAMAGES OR LOSSES), EVEN IF THE LICENSOR HAS BEEN ADVISED OF +THE POSSIBILITY OF SUCH DAMAGES. + +======================================================================= diff --git a/models/stylegan2/stylegan2-pytorch/README.md b/models/stylegan2/stylegan2-pytorch/README.md new file mode 100644 index 0000000000000000000000000000000000000000..325c7b4fe1ee3e4b72f48c0849b0c4a7136f368d --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/README.md @@ -0,0 +1,83 @@ +# StyleGAN 2 in PyTorch + +Implementation of Analyzing and Improving the Image Quality of StyleGAN (https://arxiv.org/abs/1912.04958) in PyTorch + +## Notice + +I have tried to match official implementation as close as possible, but maybe there are some details I missed. So please use this implementation with care. + +## Requirements + +I have tested on: + +* PyTorch 1.3.1 +* CUDA 10.1/10.2 + +## Usage + +First create lmdb datasets: + +> python prepare_data.py --out LMDB_PATH --n_worker N_WORKER --size SIZE1,SIZE2,SIZE3,... DATASET_PATH + +This will convert images to jpeg and pre-resizes it. This implementation does not use progressive growing, but you can create multiple resolution datasets using size arguments with comma separated lists, for the cases that you want to try another resolutions later. + +Then you can train model in distributed settings + +> python -m torch.distributed.launch --nproc_per_node=N_GPU --master_port=PORT train.py --batch BATCH_SIZE LMDB_PATH + +train.py supports Weights & Biases logging. If you want to use it, add --wandb arguments to the script. + +### Convert weight from official checkpoints + +You need to clone official repositories, (https://github.com/NVlabs/stylegan2) as it is requires for load official checkpoints. + +Next, create a conda environment with TF-GPU and Torch-CPU (using GPU for both results in CUDA version mismatches):
+`conda create -n tf_torch python=3.7 requests tensorflow-gpu=1.14 cudatoolkit=10.0 numpy=1.14 pytorch=1.6 torchvision cpuonly -c pytorch` + +For example, if you cloned repositories in ~/stylegan2 and downloaded stylegan2-ffhq-config-f.pkl, You can convert it like this: + +> python convert_weight.py --repo ~/stylegan2 stylegan2-ffhq-config-f.pkl + +This will create converted stylegan2-ffhq-config-f.pt file. + +If using GCC, you might have to set `-D_GLIBCXX_USE_CXX11_ABI=1` in `~/stylegan2/dnnlib/tflib/custom_ops.py`. + +### Generate samples + +> python generate.py --sample N_FACES --pics N_PICS --ckpt PATH_CHECKPOINT + +You should change your size (--size 256 for example) if you train with another dimension. + +### Project images to latent spaces + +> python projector.py --ckpt [CHECKPOINT] --size [GENERATOR_OUTPUT_SIZE] FILE1 FILE2 ... + +## Pretrained Checkpoints + +[Link](https://drive.google.com/open?id=1PQutd-JboOCOZqmd95XWxWrO8gGEvRcO) + +I have trained the 256px model on FFHQ 550k iterations. I got FID about 4.5. Maybe data preprocessing, resolution, training loop could made this difference, but currently I don't know the exact reason of FID differences. + +## Samples + +![Sample with truncation](doc/sample.png) + +At 110,000 iterations. (trained on 3.52M images) + +### Samples from converted weights + +![Sample from FFHQ](doc/stylegan2-ffhq-config-f.png) + +Sample from FFHQ (1024px) + +![Sample from LSUN Church](doc/stylegan2-church-config-f.png) + +Sample from LSUN Church (256px) + +## License + +Model details and custom CUDA kernel codes are from official repostiories: https://github.com/NVlabs/stylegan2 + +Codes for Learned Perceptual Image Patch Similarity, LPIPS came from https://github.com/richzhang/PerceptualSimilarity + +To match FID scores more closely to tensorflow official implementations, I have used FID Inception V3 implementations in https://github.com/mseitzer/pytorch-fid diff --git a/models/stylegan2/stylegan2-pytorch/__pycache__/model.cpython-310.pyc b/models/stylegan2/stylegan2-pytorch/__pycache__/model.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7959e797bd1658cef1418dcb454c10cb51ff12c0 Binary files /dev/null and b/models/stylegan2/stylegan2-pytorch/__pycache__/model.cpython-310.pyc differ diff --git a/models/stylegan2/stylegan2-pytorch/calc_inception.py b/models/stylegan2/stylegan2-pytorch/calc_inception.py new file mode 100644 index 0000000000000000000000000000000000000000..5daa531475c377a73ffa256bdf84bb662e144215 --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/calc_inception.py @@ -0,0 +1,116 @@ +import argparse +import pickle +import os + +import torch +from torch import nn +from torch.nn import functional as F +from torch.utils.data import DataLoader +from torchvision import transforms +from torchvision.models import inception_v3, Inception3 +import numpy as np +from tqdm import tqdm + +from inception import InceptionV3 +from dataset import MultiResolutionDataset + + +class Inception3Feature(Inception3): + def forward(self, x): + if x.shape[2] != 299 or x.shape[3] != 299: + x = F.interpolate(x, size=(299, 299), mode='bilinear', align_corners=True) + + x = self.Conv2d_1a_3x3(x) # 299 x 299 x 3 + x = self.Conv2d_2a_3x3(x) # 149 x 149 x 32 + x = self.Conv2d_2b_3x3(x) # 147 x 147 x 32 + x = F.max_pool2d(x, kernel_size=3, stride=2) # 147 x 147 x 64 + + x = self.Conv2d_3b_1x1(x) # 73 x 73 x 64 + x = self.Conv2d_4a_3x3(x) # 73 x 73 x 80 + x = F.max_pool2d(x, kernel_size=3, stride=2) # 71 x 71 x 192 + + x = self.Mixed_5b(x) # 35 x 35 x 192 + x = self.Mixed_5c(x) # 35 x 35 x 256 + x = self.Mixed_5d(x) # 35 x 35 x 288 + + x = self.Mixed_6a(x) # 35 x 35 x 288 + x = self.Mixed_6b(x) # 17 x 17 x 768 + x = self.Mixed_6c(x) # 17 x 17 x 768 + x = self.Mixed_6d(x) # 17 x 17 x 768 + x = self.Mixed_6e(x) # 17 x 17 x 768 + + x = self.Mixed_7a(x) # 17 x 17 x 768 + x = self.Mixed_7b(x) # 8 x 8 x 1280 + x = self.Mixed_7c(x) # 8 x 8 x 2048 + + x = F.avg_pool2d(x, kernel_size=8) # 8 x 8 x 2048 + + return x.view(x.shape[0], x.shape[1]) # 1 x 1 x 2048 + + +def load_patched_inception_v3(): + # inception = inception_v3(pretrained=True) + # inception_feat = Inception3Feature() + # inception_feat.load_state_dict(inception.state_dict()) + inception_feat = InceptionV3([3], normalize_input=False) + + return inception_feat + + +@torch.no_grad() +def extract_features(loader, inception, device): + pbar = tqdm(loader) + + feature_list = [] + + for img in pbar: + img = img.to(device) + feature = inception(img)[0].view(img.shape[0], -1) + feature_list.append(feature.to('cpu')) + + features = torch.cat(feature_list, 0) + + return features + + +if __name__ == '__main__': + device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') + + parser = argparse.ArgumentParser( + description='Calculate Inception v3 features for datasets' + ) + parser.add_argument('--size', type=int, default=256) + parser.add_argument('--batch', default=64, type=int, help='batch size') + parser.add_argument('--n_sample', type=int, default=50000) + parser.add_argument('--flip', action='store_true') + parser.add_argument('path', metavar='PATH', help='path to datset lmdb file') + + args = parser.parse_args() + + inception = load_patched_inception_v3() + inception = nn.DataParallel(inception).eval().to(device) + + transform = transforms.Compose( + [ + transforms.RandomHorizontalFlip(p=0.5 if args.flip else 0), + transforms.ToTensor(), + transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]), + ] + ) + + dset = MultiResolutionDataset(args.path, transform=transform, resolution=args.size) + loader = DataLoader(dset, batch_size=args.batch, num_workers=4) + + features = extract_features(loader, inception, device).numpy() + + features = features[: args.n_sample] + + print(f'extracted {features.shape[0]} features') + + mean = np.mean(features, 0) + cov = np.cov(features, rowvar=False) + + name = os.path.splitext(os.path.basename(args.path))[0] + + with open(f'inception_{name}.pkl', 'wb') as f: + pickle.dump({'mean': mean, 'cov': cov, 'size': args.size, 'path': args.path}, f) diff --git a/models/stylegan2/stylegan2-pytorch/checkpoint/.gitignore b/models/stylegan2/stylegan2-pytorch/checkpoint/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..4b6ebe5ff71ddf0402c7083d1325c4d4bcf1b045 --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/checkpoint/.gitignore @@ -0,0 +1 @@ +*.pt diff --git a/models/stylegan2/stylegan2-pytorch/convert_weight.py b/models/stylegan2/stylegan2-pytorch/convert_weight.py new file mode 100644 index 0000000000000000000000000000000000000000..09b0a02dc48e3a8736f65bfe337a8c59aa206029 --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/convert_weight.py @@ -0,0 +1,283 @@ +import argparse +import os +import sys +import pickle +import math + +import torch +import numpy as np +from torchvision import utils + +from model import Generator, Discriminator + + +def convert_modconv(vars, source_name, target_name, flip=False): + weight = vars[source_name + '/weight'].value().eval() + mod_weight = vars[source_name + '/mod_weight'].value().eval() + mod_bias = vars[source_name + '/mod_bias'].value().eval() + noise = vars[source_name + '/noise_strength'].value().eval() + bias = vars[source_name + '/bias'].value().eval() + + dic = { + 'conv.weight': np.expand_dims(weight.transpose((3, 2, 0, 1)), 0), + 'conv.modulation.weight': mod_weight.transpose((1, 0)), + 'conv.modulation.bias': mod_bias + 1, + 'noise.weight': np.array([noise]), + 'activate.bias': bias, + } + + dic_torch = {} + + for k, v in dic.items(): + dic_torch[target_name + '.' + k] = torch.from_numpy(v) + + if flip: + dic_torch[target_name + '.conv.weight'] = torch.flip( + dic_torch[target_name + '.conv.weight'], [3, 4] + ) + + return dic_torch + + +def convert_conv(vars, source_name, target_name, bias=True, start=0): + weight = vars[source_name + '/weight'].value().eval() + + dic = {'weight': weight.transpose((3, 2, 0, 1))} + + if bias: + dic['bias'] = vars[source_name + '/bias'].value().eval() + + dic_torch = {} + + dic_torch[target_name + f'.{start}.weight'] = torch.from_numpy(dic['weight']) + + if bias: + dic_torch[target_name + f'.{start + 1}.bias'] = torch.from_numpy(dic['bias']) + + return dic_torch + + +def convert_torgb(vars, source_name, target_name): + weight = vars[source_name + '/weight'].value().eval() + mod_weight = vars[source_name + '/mod_weight'].value().eval() + mod_bias = vars[source_name + '/mod_bias'].value().eval() + bias = vars[source_name + '/bias'].value().eval() + + dic = { + 'conv.weight': np.expand_dims(weight.transpose((3, 2, 0, 1)), 0), + 'conv.modulation.weight': mod_weight.transpose((1, 0)), + 'conv.modulation.bias': mod_bias + 1, + 'bias': bias.reshape((1, 3, 1, 1)), + } + + dic_torch = {} + + for k, v in dic.items(): + dic_torch[target_name + '.' + k] = torch.from_numpy(v) + + return dic_torch + + +def convert_dense(vars, source_name, target_name): + weight = vars[source_name + '/weight'].value().eval() + bias = vars[source_name + '/bias'].value().eval() + + dic = {'weight': weight.transpose((1, 0)), 'bias': bias} + + dic_torch = {} + + for k, v in dic.items(): + dic_torch[target_name + '.' + k] = torch.from_numpy(v) + + return dic_torch + + +def update(state_dict, new): + for k, v in new.items(): + if k not in state_dict: + raise KeyError(k + ' is not found') + + if v.shape != state_dict[k].shape: + raise ValueError(f'Shape mismatch: {v.shape} vs {state_dict[k].shape}') + + state_dict[k] = v + + +def discriminator_fill_statedict(statedict, vars, size): + log_size = int(math.log(size, 2)) + + update(statedict, convert_conv(vars, f'{size}x{size}/FromRGB', 'convs.0')) + + conv_i = 1 + + for i in range(log_size - 2, 0, -1): + reso = 4 * 2 ** i + update( + statedict, + convert_conv(vars, f'{reso}x{reso}/Conv0', f'convs.{conv_i}.conv1'), + ) + update( + statedict, + convert_conv( + vars, f'{reso}x{reso}/Conv1_down', f'convs.{conv_i}.conv2', start=1 + ), + ) + update( + statedict, + convert_conv( + vars, f'{reso}x{reso}/Skip', f'convs.{conv_i}.skip', start=1, bias=False + ), + ) + conv_i += 1 + + update(statedict, convert_conv(vars, f'4x4/Conv', 'final_conv')) + update(statedict, convert_dense(vars, f'4x4/Dense0', 'final_linear.0')) + update(statedict, convert_dense(vars, f'Output', 'final_linear.1')) + + return statedict + + +def fill_statedict(state_dict, vars, size): + log_size = int(math.log(size, 2)) + + for i in range(8): + update(state_dict, convert_dense(vars, f'G_mapping/Dense{i}', f'style.{i + 1}')) + + update( + state_dict, + { + 'input.input': torch.from_numpy( + vars['G_synthesis/4x4/Const/const'].value().eval() + ) + }, + ) + + update(state_dict, convert_torgb(vars, 'G_synthesis/4x4/ToRGB', 'to_rgb1')) + + for i in range(log_size - 2): + reso = 4 * 2 ** (i + 1) + update( + state_dict, + convert_torgb(vars, f'G_synthesis/{reso}x{reso}/ToRGB', f'to_rgbs.{i}'), + ) + + update(state_dict, convert_modconv(vars, 'G_synthesis/4x4/Conv', 'conv1')) + + conv_i = 0 + + for i in range(log_size - 2): + reso = 4 * 2 ** (i + 1) + update( + state_dict, + convert_modconv( + vars, + f'G_synthesis/{reso}x{reso}/Conv0_up', + f'convs.{conv_i}', + flip=True, + ), + ) + update( + state_dict, + convert_modconv( + vars, f'G_synthesis/{reso}x{reso}/Conv1', f'convs.{conv_i + 1}' + ), + ) + conv_i += 2 + + for i in range(0, (log_size - 2) * 2 + 1): + update( + state_dict, + { + f'noises.noise_{i}': torch.from_numpy( + vars[f'G_synthesis/noise{i}'].value().eval() + ) + }, + ) + + return state_dict + + +if __name__ == '__main__': + device = 'cuda' if torch.cuda.is_available() else 'cpu' + print('Using PyTorch device', device) + + parser = argparse.ArgumentParser() + parser.add_argument('--repo', type=str, required=True) + parser.add_argument('--gen', action='store_true') + parser.add_argument('--disc', action='store_true') + parser.add_argument('--channel_multiplier', type=int, default=2) + parser.add_argument('path', metavar='PATH') + + args = parser.parse_args() + + sys.path.append(args.repo) + + import dnnlib + from dnnlib import tflib + + tflib.init_tf() + + with open(args.path, 'rb') as f: + generator, discriminator, g_ema = pickle.load(f) + + size = g_ema.output_shape[2] + + g = Generator(size, 512, 8, channel_multiplier=args.channel_multiplier) + state_dict = g.state_dict() + state_dict = fill_statedict(state_dict, g_ema.vars, size) + + g.load_state_dict(state_dict) + + latent_avg = torch.from_numpy(g_ema.vars['dlatent_avg'].value().eval()) + + ckpt = {'g_ema': state_dict, 'latent_avg': latent_avg} + + if args.gen: + g_train = Generator(size, 512, 8, channel_multiplier=args.channel_multiplier) + g_train_state = g_train.state_dict() + g_train_state = fill_statedict(g_train_state, generator.vars, size) + ckpt['g'] = g_train_state + + if args.disc: + disc = Discriminator(size, channel_multiplier=args.channel_multiplier) + d_state = disc.state_dict() + d_state = discriminator_fill_statedict(d_state, discriminator.vars, size) + ckpt['d'] = d_state + + name = os.path.splitext(os.path.basename(args.path))[0] + outpath = os.path.join(os.getcwd(), f'{name}.pt') + print('Saving', outpath) + try: + torch.save(ckpt, outpath, _use_new_zipfile_serialization=False) + except TypeError: + torch.save(ckpt, outpath) + + + print('Generating TF-Torch comparison images') + batch_size = {256: 8, 512: 4, 1024: 2} + n_sample = batch_size.get(size, 4) + + g = g.to(device) + + z = np.random.RandomState(0).randn(n_sample, 512).astype('float32') + + with torch.no_grad(): + img_pt, _ = g( + [torch.from_numpy(z).to(device)], + truncation=0.5, + truncation_latent=latent_avg.to(device), + ) + + img_tf = g_ema.run(z, None, randomize_noise=False) + img_tf = torch.from_numpy(img_tf).to(device) + + img_diff = ((img_pt + 1) / 2).clamp(0.0, 1.0) - ((img_tf.to(device) + 1) / 2).clamp( + 0.0, 1.0 + ) + + img_concat = torch.cat((img_tf, img_pt, img_diff), dim=0) + utils.save_image( + img_concat, name + '.png', nrow=n_sample, normalize=True, range=(-1, 1) + ) + print('Done') + diff --git a/models/stylegan2/stylegan2-pytorch/dataset.py b/models/stylegan2/stylegan2-pytorch/dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..7713ea2f8bc94d202d2dfbe830af3cb96b1e803d --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/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/models/stylegan2/stylegan2-pytorch/distributed.py b/models/stylegan2/stylegan2-pytorch/distributed.py new file mode 100644 index 0000000000000000000000000000000000000000..51fa243257ef302e2015d5ff36ac531b86a9a0ce --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/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/models/stylegan2/stylegan2-pytorch/doc/sample.png b/models/stylegan2/stylegan2-pytorch/doc/sample.png new file mode 100644 index 0000000000000000000000000000000000000000..f8ad5ae7d975e32e4ffaef27dc459ea44143478d --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/doc/sample.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:932144cd9c506989c3b1db55eeea2bccb5482d9b4bff60828e9fc107fd872676 +size 7069003 diff --git a/models/stylegan2/stylegan2-pytorch/doc/stylegan2-church-config-f.png b/models/stylegan2/stylegan2-pytorch/doc/stylegan2-church-config-f.png new file mode 100644 index 0000000000000000000000000000000000000000..5c29aa650549549febcf89103b108b6151665cc3 --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/doc/stylegan2-church-config-f.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ced99c38c9563d224d69b441fb95893aae3c648399aa57cd20f6e4ffb6a09654 +size 1951443 diff --git a/models/stylegan2/stylegan2-pytorch/fid.py b/models/stylegan2/stylegan2-pytorch/fid.py new file mode 100644 index 0000000000000000000000000000000000000000..c05eeda26b3a5ae5be060c158fc7a74d4ccbfb5f --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/fid.py @@ -0,0 +1,107 @@ +import argparse +import pickle + +import torch +from torch import nn +import numpy as np +from scipy import linalg +from tqdm import tqdm + +from model import Generator +from calc_inception import load_patched_inception_v3 + + +@torch.no_grad() +def extract_feature_from_samples( + generator, inception, truncation, truncation_latent, batch_size, n_sample, device +): + n_batch = n_sample // batch_size + resid = n_sample - (n_batch * batch_size) + batch_sizes = [batch_size] * n_batch + [resid] + features = [] + + for batch in tqdm(batch_sizes): + latent = torch.randn(batch, 512, device=device) + img, _ = g([latent], truncation=truncation, truncation_latent=truncation_latent) + feat = inception(img)[0].view(img.shape[0], -1) + features.append(feat.to('cpu')) + + features = torch.cat(features, 0) + + return features + + +def calc_fid(sample_mean, sample_cov, real_mean, real_cov, eps=1e-6): + cov_sqrt, _ = linalg.sqrtm(sample_cov @ real_cov, disp=False) + + if not np.isfinite(cov_sqrt).all(): + print('product of cov matrices is singular') + offset = np.eye(sample_cov.shape[0]) * eps + cov_sqrt = linalg.sqrtm((sample_cov + offset) @ (real_cov + offset)) + + if np.iscomplexobj(cov_sqrt): + if not np.allclose(np.diagonal(cov_sqrt).imag, 0, atol=1e-3): + m = np.max(np.abs(cov_sqrt.imag)) + + raise ValueError(f'Imaginary component {m}') + + cov_sqrt = cov_sqrt.real + + mean_diff = sample_mean - real_mean + mean_norm = mean_diff @ mean_diff + + trace = np.trace(sample_cov) + np.trace(real_cov) - 2 * np.trace(cov_sqrt) + + fid = mean_norm + trace + + return fid + + +if __name__ == '__main__': + device = 'cuda' + + parser = argparse.ArgumentParser() + + parser.add_argument('--truncation', type=float, default=1) + parser.add_argument('--truncation_mean', type=int, default=4096) + parser.add_argument('--batch', type=int, default=64) + parser.add_argument('--n_sample', type=int, default=50000) + parser.add_argument('--size', type=int, default=256) + parser.add_argument('--inception', type=str, default=None, required=True) + parser.add_argument('ckpt', metavar='CHECKPOINT') + + args = parser.parse_args() + + ckpt = torch.load(args.ckpt) + + g = Generator(args.size, 512, 8).to(device) + g.load_state_dict(ckpt['g_ema']) + g = nn.DataParallel(g) + g.eval() + + if args.truncation < 1: + with torch.no_grad(): + mean_latent = g.mean_latent(args.truncation_mean) + + else: + mean_latent = None + + inception = nn.DataParallel(load_patched_inception_v3()).to(device) + inception.eval() + + features = extract_feature_from_samples( + g, inception, args.truncation, mean_latent, args.batch, args.n_sample, device + ).numpy() + print(f'extracted {features.shape[0]} features') + + sample_mean = np.mean(features, 0) + sample_cov = np.cov(features, rowvar=False) + + with open(args.inception, 'rb') as f: + embeds = pickle.load(f) + real_mean = embeds['mean'] + real_cov = embeds['cov'] + + fid = calc_fid(sample_mean, sample_cov, real_mean, real_cov) + + print('fid:', fid) diff --git a/models/stylegan2/stylegan2-pytorch/generate.py b/models/stylegan2/stylegan2-pytorch/generate.py new file mode 100644 index 0000000000000000000000000000000000000000..4255c8cb0a16817b3f4d60783456bfa5cd15d018 --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/generate.py @@ -0,0 +1,55 @@ +import argparse + +import torch +from torchvision import utils +from model import Generator +from tqdm import tqdm +def generate(args, g_ema, device, mean_latent): + + with torch.no_grad(): + g_ema.eval() + for i in tqdm(range(args.pics)): + sample_z = torch.randn(args.sample, args.latent, device=device) + + sample, _ = g_ema([sample_z], truncation=args.truncation, truncation_latent=mean_latent) + + utils.save_image( + sample, + f'sample/{str(i).zfill(6)}.png', + nrow=1, + normalize=True, + range=(-1, 1), + ) + +if __name__ == '__main__': + device = 'cuda' + + parser = argparse.ArgumentParser() + + parser.add_argument('--size', type=int, default=1024) + parser.add_argument('--sample', type=int, default=1) + parser.add_argument('--pics', type=int, default=20) + parser.add_argument('--truncation', type=float, default=1) + parser.add_argument('--truncation_mean', type=int, default=4096) + parser.add_argument('--ckpt', type=str, default="stylegan2-ffhq-config-f.pt") + parser.add_argument('--channel_multiplier', type=int, default=2) + + args = parser.parse_args() + + 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']) + + if args.truncation < 1: + with torch.no_grad(): + mean_latent = g_ema.mean_latent(args.truncation_mean) + else: + mean_latent = None + + generate(args, g_ema, device, mean_latent) diff --git a/models/stylegan2/stylegan2-pytorch/inception.py b/models/stylegan2/stylegan2-pytorch/inception.py new file mode 100644 index 0000000000000000000000000000000000000000..f3afed8123e595f65c1333dea7151e653a836e2b --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/inception.py @@ -0,0 +1,310 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +from torchvision import models + +try: + from torchvision.models.utils import load_state_dict_from_url +except ImportError: + from torch.utils.model_zoo import load_url as load_state_dict_from_url + +# Inception weights ported to Pytorch from +# http://download.tensorflow.org/models/image/imagenet/inception-2015-12-05.tgz +FID_WEIGHTS_URL = 'https://github.com/mseitzer/pytorch-fid/releases/download/fid_weights/pt_inception-2015-12-05-6726825d.pth' + + +class InceptionV3(nn.Module): + """Pretrained InceptionV3 network returning feature maps""" + + # Index of default block of inception to return, + # corresponds to output of final average pooling + DEFAULT_BLOCK_INDEX = 3 + + # Maps feature dimensionality to their output blocks indices + BLOCK_INDEX_BY_DIM = { + 64: 0, # First max pooling features + 192: 1, # Second max pooling featurs + 768: 2, # Pre-aux classifier features + 2048: 3 # Final average pooling features + } + + def __init__(self, + output_blocks=[DEFAULT_BLOCK_INDEX], + resize_input=True, + normalize_input=True, + requires_grad=False, + use_fid_inception=True): + """Build pretrained InceptionV3 + + Parameters + ---------- + output_blocks : list of int + Indices of blocks to return features of. Possible values are: + - 0: corresponds to output of first max pooling + - 1: corresponds to output of second max pooling + - 2: corresponds to output which is fed to aux classifier + - 3: corresponds to output of final average pooling + resize_input : bool + If true, bilinearly resizes input to width and height 299 before + feeding input to model. As the network without fully connected + layers is fully convolutional, it should be able to handle inputs + of arbitrary size, so resizing might not be strictly needed + normalize_input : bool + If true, scales the input from range (0, 1) to the range the + pretrained Inception network expects, namely (-1, 1) + requires_grad : bool + If true, parameters of the model require gradients. Possibly useful + for finetuning the network + use_fid_inception : bool + If true, uses the pretrained Inception model used in Tensorflow's + FID implementation. If false, uses the pretrained Inception model + available in torchvision. The FID Inception model has different + weights and a slightly different structure from torchvision's + Inception model. If you want to compute FID scores, you are + strongly advised to set this parameter to true to get comparable + results. + """ + super(InceptionV3, self).__init__() + + self.resize_input = resize_input + self.normalize_input = normalize_input + self.output_blocks = sorted(output_blocks) + self.last_needed_block = max(output_blocks) + + assert self.last_needed_block <= 3, \ + 'Last possible output block index is 3' + + self.blocks = nn.ModuleList() + + if use_fid_inception: + inception = fid_inception_v3() + else: + inception = models.inception_v3(pretrained=True) + + # Block 0: input to maxpool1 + block0 = [ + inception.Conv2d_1a_3x3, + inception.Conv2d_2a_3x3, + inception.Conv2d_2b_3x3, + nn.MaxPool2d(kernel_size=3, stride=2) + ] + self.blocks.append(nn.Sequential(*block0)) + + # Block 1: maxpool1 to maxpool2 + if self.last_needed_block >= 1: + block1 = [ + inception.Conv2d_3b_1x1, + inception.Conv2d_4a_3x3, + nn.MaxPool2d(kernel_size=3, stride=2) + ] + self.blocks.append(nn.Sequential(*block1)) + + # Block 2: maxpool2 to aux classifier + if self.last_needed_block >= 2: + block2 = [ + inception.Mixed_5b, + inception.Mixed_5c, + inception.Mixed_5d, + inception.Mixed_6a, + inception.Mixed_6b, + inception.Mixed_6c, + inception.Mixed_6d, + inception.Mixed_6e, + ] + self.blocks.append(nn.Sequential(*block2)) + + # Block 3: aux classifier to final avgpool + if self.last_needed_block >= 3: + block3 = [ + inception.Mixed_7a, + inception.Mixed_7b, + inception.Mixed_7c, + nn.AdaptiveAvgPool2d(output_size=(1, 1)) + ] + self.blocks.append(nn.Sequential(*block3)) + + for param in self.parameters(): + param.requires_grad = requires_grad + + def forward(self, inp): + """Get Inception feature maps + + Parameters + ---------- + inp : torch.autograd.Variable + Input tensor of shape Bx3xHxW. Values are expected to be in + range (0, 1) + + Returns + ------- + List of torch.autograd.Variable, corresponding to the selected output + block, sorted ascending by index + """ + outp = [] + x = inp + + if self.resize_input: + x = F.interpolate(x, + size=(299, 299), + mode='bilinear', + align_corners=False) + + if self.normalize_input: + x = 2 * x - 1 # Scale from range (0, 1) to range (-1, 1) + + for idx, block in enumerate(self.blocks): + x = block(x) + if idx in self.output_blocks: + outp.append(x) + + if idx == self.last_needed_block: + break + + return outp + + +def fid_inception_v3(): + """Build pretrained Inception model for FID computation + + The Inception model for FID computation uses a different set of weights + and has a slightly different structure than torchvision's Inception. + + This method first constructs torchvision's Inception and then patches the + necessary parts that are different in the FID Inception model. + """ + inception = models.inception_v3(num_classes=1008, + aux_logits=False, + pretrained=False) + inception.Mixed_5b = FIDInceptionA(192, pool_features=32) + inception.Mixed_5c = FIDInceptionA(256, pool_features=64) + inception.Mixed_5d = FIDInceptionA(288, pool_features=64) + inception.Mixed_6b = FIDInceptionC(768, channels_7x7=128) + inception.Mixed_6c = FIDInceptionC(768, channels_7x7=160) + inception.Mixed_6d = FIDInceptionC(768, channels_7x7=160) + inception.Mixed_6e = FIDInceptionC(768, channels_7x7=192) + inception.Mixed_7b = FIDInceptionE_1(1280) + inception.Mixed_7c = FIDInceptionE_2(2048) + + state_dict = load_state_dict_from_url(FID_WEIGHTS_URL, progress=True) + inception.load_state_dict(state_dict) + return inception + + +class FIDInceptionA(models.inception.InceptionA): + """InceptionA block patched for FID computation""" + def __init__(self, in_channels, pool_features): + super(FIDInceptionA, self).__init__(in_channels, pool_features) + + def forward(self, x): + branch1x1 = self.branch1x1(x) + + branch5x5 = self.branch5x5_1(x) + branch5x5 = self.branch5x5_2(branch5x5) + + branch3x3dbl = self.branch3x3dbl_1(x) + branch3x3dbl = self.branch3x3dbl_2(branch3x3dbl) + branch3x3dbl = self.branch3x3dbl_3(branch3x3dbl) + + # Patch: Tensorflow's average pool does not use the padded zero's in + # its average calculation + branch_pool = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1, + count_include_pad=False) + branch_pool = self.branch_pool(branch_pool) + + outputs = [branch1x1, branch5x5, branch3x3dbl, branch_pool] + return torch.cat(outputs, 1) + + +class FIDInceptionC(models.inception.InceptionC): + """InceptionC block patched for FID computation""" + def __init__(self, in_channels, channels_7x7): + super(FIDInceptionC, self).__init__(in_channels, channels_7x7) + + def forward(self, x): + branch1x1 = self.branch1x1(x) + + branch7x7 = self.branch7x7_1(x) + branch7x7 = self.branch7x7_2(branch7x7) + branch7x7 = self.branch7x7_3(branch7x7) + + branch7x7dbl = self.branch7x7dbl_1(x) + branch7x7dbl = self.branch7x7dbl_2(branch7x7dbl) + branch7x7dbl = self.branch7x7dbl_3(branch7x7dbl) + branch7x7dbl = self.branch7x7dbl_4(branch7x7dbl) + branch7x7dbl = self.branch7x7dbl_5(branch7x7dbl) + + # Patch: Tensorflow's average pool does not use the padded zero's in + # its average calculation + branch_pool = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1, + count_include_pad=False) + branch_pool = self.branch_pool(branch_pool) + + outputs = [branch1x1, branch7x7, branch7x7dbl, branch_pool] + return torch.cat(outputs, 1) + + +class FIDInceptionE_1(models.inception.InceptionE): + """First InceptionE block patched for FID computation""" + def __init__(self, in_channels): + super(FIDInceptionE_1, self).__init__(in_channels) + + def forward(self, x): + branch1x1 = self.branch1x1(x) + + branch3x3 = self.branch3x3_1(x) + branch3x3 = [ + self.branch3x3_2a(branch3x3), + self.branch3x3_2b(branch3x3), + ] + branch3x3 = torch.cat(branch3x3, 1) + + branch3x3dbl = self.branch3x3dbl_1(x) + branch3x3dbl = self.branch3x3dbl_2(branch3x3dbl) + branch3x3dbl = [ + self.branch3x3dbl_3a(branch3x3dbl), + self.branch3x3dbl_3b(branch3x3dbl), + ] + branch3x3dbl = torch.cat(branch3x3dbl, 1) + + # Patch: Tensorflow's average pool does not use the padded zero's in + # its average calculation + branch_pool = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1, + count_include_pad=False) + branch_pool = self.branch_pool(branch_pool) + + outputs = [branch1x1, branch3x3, branch3x3dbl, branch_pool] + return torch.cat(outputs, 1) + + +class FIDInceptionE_2(models.inception.InceptionE): + """Second InceptionE block patched for FID computation""" + def __init__(self, in_channels): + super(FIDInceptionE_2, self).__init__(in_channels) + + def forward(self, x): + branch1x1 = self.branch1x1(x) + + branch3x3 = self.branch3x3_1(x) + branch3x3 = [ + self.branch3x3_2a(branch3x3), + self.branch3x3_2b(branch3x3), + ] + branch3x3 = torch.cat(branch3x3, 1) + + branch3x3dbl = self.branch3x3dbl_1(x) + branch3x3dbl = self.branch3x3dbl_2(branch3x3dbl) + branch3x3dbl = [ + self.branch3x3dbl_3a(branch3x3dbl), + self.branch3x3dbl_3b(branch3x3dbl), + ] + branch3x3dbl = torch.cat(branch3x3dbl, 1) + + # Patch: The FID Inception model uses max pooling instead of average + # pooling. This is likely an error in this specific Inception + # implementation, as other Inception models use average pooling here + # (which matches the description in the paper). + branch_pool = F.max_pool2d(x, kernel_size=3, stride=1, padding=1) + branch_pool = self.branch_pool(branch_pool) + + outputs = [branch1x1, branch3x3, branch3x3dbl, branch_pool] + return torch.cat(outputs, 1) diff --git a/models/stylegan2/stylegan2-pytorch/inception_ffhq.pkl b/models/stylegan2/stylegan2-pytorch/inception_ffhq.pkl new file mode 100644 index 0000000000000000000000000000000000000000..f1f5a2af6a2e08efae84d53f55b65b161686c189 --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/inception_ffhq.pkl @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:75676eeaa3db6eeb59411675ac7ab21c100810b18de6ca6129bd1b1e9aa7d413 +size 33562936 diff --git a/models/stylegan2/stylegan2-pytorch/lpips/__init__.py b/models/stylegan2/stylegan2-pytorch/lpips/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a4f86b7ee229b333a64f16d0091e988492f99c58 --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/lpips/__init__.py @@ -0,0 +1,160 @@ + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import numpy as np +from skimage.measure import compare_ssim +import torch +from torch.autograd import Variable + +from lpips import dist_model + +class PerceptualLoss(torch.nn.Module): + def __init__(self, model='net-lin', net='alex', colorspace='rgb', spatial=False, use_gpu=True, gpu_ids=[0]): # VGG using our perceptually-learned weights (LPIPS metric) + # def __init__(self, model='net', net='vgg', use_gpu=True): # "default" way of using VGG as a perceptual loss + super(PerceptualLoss, self).__init__() + print('Setting up Perceptual loss...') + self.use_gpu = use_gpu + self.spatial = spatial + self.gpu_ids = gpu_ids + self.model = dist_model.DistModel() + self.model.initialize(model=model, net=net, use_gpu=use_gpu, colorspace=colorspace, spatial=self.spatial, gpu_ids=gpu_ids) + print('...[%s] initialized'%self.model.name()) + print('...Done') + + def forward(self, pred, target, normalize=False): + """ + Pred and target are Variables. + If normalize is True, assumes the images are between [0,1] and then scales them between [-1,+1] + If normalize is False, assumes the images are already between [-1,+1] + + Inputs pred and target are Nx3xHxW + Output pytorch Variable N long + """ + + if normalize: + target = 2 * target - 1 + pred = 2 * pred - 1 + + return self.model.forward(target, pred) + +def normalize_tensor(in_feat,eps=1e-10): + norm_factor = torch.sqrt(torch.sum(in_feat**2,dim=1,keepdim=True)) + return in_feat/(norm_factor+eps) + +def l2(p0, p1, range=255.): + return .5*np.mean((p0 / range - p1 / range)**2) + +def psnr(p0, p1, peak=255.): + return 10*np.log10(peak**2/np.mean((1.*p0-1.*p1)**2)) + +def dssim(p0, p1, range=255.): + return (1 - compare_ssim(p0, p1, data_range=range, multichannel=True)) / 2. + +def rgb2lab(in_img,mean_cent=False): + from skimage import color + img_lab = color.rgb2lab(in_img) + if(mean_cent): + img_lab[:,:,0] = img_lab[:,:,0]-50 + return img_lab + +def tensor2np(tensor_obj): + # change dimension of a tensor object into a numpy array + return tensor_obj[0].cpu().float().numpy().transpose((1,2,0)) + +def np2tensor(np_obj): + # change dimenion of np array into tensor array + return torch.Tensor(np_obj[:, :, :, np.newaxis].transpose((3, 2, 0, 1))) + +def tensor2tensorlab(image_tensor,to_norm=True,mc_only=False): + # image tensor to lab tensor + from skimage import color + + img = tensor2im(image_tensor) + img_lab = color.rgb2lab(img) + if(mc_only): + img_lab[:,:,0] = img_lab[:,:,0]-50 + if(to_norm and not mc_only): + img_lab[:,:,0] = img_lab[:,:,0]-50 + img_lab = img_lab/100. + + return np2tensor(img_lab) + +def tensorlab2tensor(lab_tensor,return_inbnd=False): + from skimage import color + import warnings + warnings.filterwarnings("ignore") + + lab = tensor2np(lab_tensor)*100. + lab[:,:,0] = lab[:,:,0]+50 + + rgb_back = 255.*np.clip(color.lab2rgb(lab.astype('float')),0,1) + if(return_inbnd): + # convert back to lab, see if we match + lab_back = color.rgb2lab(rgb_back.astype('uint8')) + mask = 1.*np.isclose(lab_back,lab,atol=2.) + mask = np2tensor(np.prod(mask,axis=2)[:,:,np.newaxis]) + return (im2tensor(rgb_back),mask) + else: + return im2tensor(rgb_back) + +def rgb2lab(input): + from skimage import color + return color.rgb2lab(input / 255.) + +def tensor2im(image_tensor, imtype=np.uint8, cent=1., factor=255./2.): + image_numpy = image_tensor[0].cpu().float().numpy() + image_numpy = (np.transpose(image_numpy, (1, 2, 0)) + cent) * factor + return image_numpy.astype(imtype) + +def im2tensor(image, imtype=np.uint8, cent=1., factor=255./2.): + return torch.Tensor((image / factor - cent) + [:, :, :, np.newaxis].transpose((3, 2, 0, 1))) + +def tensor2vec(vector_tensor): + return vector_tensor.data.cpu().numpy()[:, :, 0, 0] + +def voc_ap(rec, prec, use_07_metric=False): + """ ap = voc_ap(rec, prec, [use_07_metric]) + Compute VOC AP given precision and recall. + If use_07_metric is true, uses the + VOC 07 11 point method (default:False). + """ + if use_07_metric: + # 11 point metric + ap = 0. + for t in np.arange(0., 1.1, 0.1): + if np.sum(rec >= t) == 0: + p = 0 + else: + p = np.max(prec[rec >= t]) + ap = ap + p / 11. + else: + # correct AP calculation + # first append sentinel values at the end + mrec = np.concatenate(([0.], rec, [1.])) + mpre = np.concatenate(([0.], prec, [0.])) + + # compute the precision envelope + for i in range(mpre.size - 1, 0, -1): + mpre[i - 1] = np.maximum(mpre[i - 1], mpre[i]) + + # to calculate area under PR curve, look for points + # where X axis (recall) changes value + i = np.where(mrec[1:] != mrec[:-1])[0] + + # and sum (\Delta recall) * prec + ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1]) + return ap + +def tensor2im(image_tensor, imtype=np.uint8, cent=1., factor=255./2.): +# def tensor2im(image_tensor, imtype=np.uint8, cent=1., factor=1.): + image_numpy = image_tensor[0].cpu().float().numpy() + image_numpy = (np.transpose(image_numpy, (1, 2, 0)) + cent) * factor + return image_numpy.astype(imtype) + +def im2tensor(image, imtype=np.uint8, cent=1., factor=255./2.): +# def im2tensor(image, imtype=np.uint8, cent=1., factor=1.): + return torch.Tensor((image / factor - cent) + [:, :, :, np.newaxis].transpose((3, 2, 0, 1))) diff --git a/models/stylegan2/stylegan2-pytorch/lpips/base_model.py b/models/stylegan2/stylegan2-pytorch/lpips/base_model.py new file mode 100644 index 0000000000000000000000000000000000000000..8de1d16f0c7fa52d8067139abc6e769e96d0a6a1 --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/lpips/base_model.py @@ -0,0 +1,58 @@ +import os +import numpy as np +import torch +from torch.autograd import Variable +from pdb import set_trace as st +from IPython import embed + +class BaseModel(): + def __init__(self): + pass; + + def name(self): + return 'BaseModel' + + def initialize(self, use_gpu=True, gpu_ids=[0]): + self.use_gpu = use_gpu + self.gpu_ids = gpu_ids + + def forward(self): + pass + + def get_image_paths(self): + pass + + def optimize_parameters(self): + pass + + def get_current_visuals(self): + return self.input + + def get_current_errors(self): + return {} + + def save(self, label): + pass + + # helper saving function that can be used by subclasses + def save_network(self, network, path, network_label, epoch_label): + save_filename = '%s_net_%s.pth' % (epoch_label, network_label) + save_path = os.path.join(path, save_filename) + torch.save(network.state_dict(), save_path) + + # helper loading function that can be used by subclasses + def load_network(self, network, network_label, epoch_label): + save_filename = '%s_net_%s.pth' % (epoch_label, network_label) + save_path = os.path.join(self.save_dir, save_filename) + print('Loading network from %s'%save_path) + network.load_state_dict(torch.load(save_path)) + + def update_learning_rate(): + pass + + def get_image_paths(self): + return self.image_paths + + def save_done(self, flag=False): + np.save(os.path.join(self.save_dir, 'done_flag'),flag) + np.savetxt(os.path.join(self.save_dir, 'done_flag'),[flag,],fmt='%i') diff --git a/models/stylegan2/stylegan2-pytorch/lpips/dist_model.py b/models/stylegan2/stylegan2-pytorch/lpips/dist_model.py new file mode 100644 index 0000000000000000000000000000000000000000..4ff0aa4ca6e4b217954c167787eaac1ca1f8e304 --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/lpips/dist_model.py @@ -0,0 +1,284 @@ + +from __future__ import absolute_import + +import sys +import numpy as np +import torch +from torch import nn +import os +from collections import OrderedDict +from torch.autograd import Variable +import itertools +from .base_model import BaseModel +from scipy.ndimage import zoom +import fractions +import functools +import skimage.transform +from tqdm import tqdm + +from IPython import embed + +from . import networks_basic as networks +import lpips as util + +class DistModel(BaseModel): + def name(self): + return self.model_name + + def initialize(self, model='net-lin', net='alex', colorspace='Lab', pnet_rand=False, pnet_tune=False, model_path=None, + use_gpu=True, printNet=False, spatial=False, + is_train=False, lr=.0001, beta1=0.5, version='0.1', gpu_ids=[0]): + ''' + INPUTS + model - ['net-lin'] for linearly calibrated network + ['net'] for off-the-shelf network + ['L2'] for L2 distance in Lab colorspace + ['SSIM'] for ssim in RGB colorspace + net - ['squeeze','alex','vgg'] + model_path - if None, will look in weights/[NET_NAME].pth + colorspace - ['Lab','RGB'] colorspace to use for L2 and SSIM + use_gpu - bool - whether or not to use a GPU + printNet - bool - whether or not to print network architecture out + spatial - bool - whether to output an array containing varying distances across spatial dimensions + spatial_shape - if given, output spatial shape. if None then spatial shape is determined automatically via spatial_factor (see below). + spatial_factor - if given, specifies upsampling factor relative to the largest spatial extent of a convolutional layer. if None then resized to size of input images. + spatial_order - spline order of filter for upsampling in spatial mode, by default 1 (bilinear). + is_train - bool - [True] for training mode + lr - float - initial learning rate + beta1 - float - initial momentum term for adam + version - 0.1 for latest, 0.0 was original (with a bug) + gpu_ids - int array - [0] by default, gpus to use + ''' + BaseModel.initialize(self, use_gpu=use_gpu, gpu_ids=gpu_ids) + + self.model = model + self.net = net + self.is_train = is_train + self.spatial = spatial + self.gpu_ids = gpu_ids + self.model_name = '%s [%s]'%(model,net) + + if(self.model == 'net-lin'): # pretrained net + linear layer + self.net = networks.PNetLin(pnet_rand=pnet_rand, pnet_tune=pnet_tune, pnet_type=net, + use_dropout=True, spatial=spatial, version=version, lpips=True) + kw = {} + if not use_gpu: + kw['map_location'] = 'cpu' + if(model_path is None): + import inspect + model_path = os.path.abspath(os.path.join(inspect.getfile(self.initialize), '..', 'weights/v%s/%s.pth'%(version,net))) + + if(not is_train): + print('Loading model from: %s'%model_path) + self.net.load_state_dict(torch.load(model_path, **kw), strict=False) + + elif(self.model=='net'): # pretrained network + self.net = networks.PNetLin(pnet_rand=pnet_rand, pnet_type=net, lpips=False) + elif(self.model in ['L2','l2']): + self.net = networks.L2(use_gpu=use_gpu,colorspace=colorspace) # not really a network, only for testing + self.model_name = 'L2' + elif(self.model in ['DSSIM','dssim','SSIM','ssim']): + self.net = networks.DSSIM(use_gpu=use_gpu,colorspace=colorspace) + self.model_name = 'SSIM' + else: + raise ValueError("Model [%s] not recognized." % self.model) + + self.parameters = list(self.net.parameters()) + + if self.is_train: # training mode + # extra network on top to go from distances (d0,d1) => predicted human judgment (h*) + self.rankLoss = networks.BCERankingLoss() + self.parameters += list(self.rankLoss.net.parameters()) + self.lr = lr + self.old_lr = lr + self.optimizer_net = torch.optim.Adam(self.parameters, lr=lr, betas=(beta1, 0.999)) + else: # test mode + self.net.eval() + + if(use_gpu): + self.net.to(gpu_ids[0]) + self.net = torch.nn.DataParallel(self.net, device_ids=gpu_ids) + if(self.is_train): + self.rankLoss = self.rankLoss.to(device=gpu_ids[0]) # just put this on GPU0 + + if(printNet): + print('---------- Networks initialized -------------') + networks.print_network(self.net) + print('-----------------------------------------------') + + def forward(self, in0, in1, retPerLayer=False): + ''' Function computes the distance between image patches in0 and in1 + INPUTS + in0, in1 - torch.Tensor object of shape Nx3xXxY - image patch scaled to [-1,1] + OUTPUT + computed distances between in0 and in1 + ''' + + return self.net.forward(in0, in1, retPerLayer=retPerLayer) + + # ***** TRAINING FUNCTIONS ***** + def optimize_parameters(self): + self.forward_train() + self.optimizer_net.zero_grad() + self.backward_train() + self.optimizer_net.step() + self.clamp_weights() + + def clamp_weights(self): + for module in self.net.modules(): + if(hasattr(module, 'weight') and module.kernel_size==(1,1)): + module.weight.data = torch.clamp(module.weight.data,min=0) + + def set_input(self, data): + self.input_ref = data['ref'] + self.input_p0 = data['p0'] + self.input_p1 = data['p1'] + self.input_judge = data['judge'] + + if(self.use_gpu): + self.input_ref = self.input_ref.to(device=self.gpu_ids[0]) + self.input_p0 = self.input_p0.to(device=self.gpu_ids[0]) + self.input_p1 = self.input_p1.to(device=self.gpu_ids[0]) + self.input_judge = self.input_judge.to(device=self.gpu_ids[0]) + + self.var_ref = Variable(self.input_ref,requires_grad=True) + self.var_p0 = Variable(self.input_p0,requires_grad=True) + self.var_p1 = Variable(self.input_p1,requires_grad=True) + + def forward_train(self): # run forward pass + # print(self.net.module.scaling_layer.shift) + # print(torch.norm(self.net.module.net.slice1[0].weight).item(), torch.norm(self.net.module.lin0.model[1].weight).item()) + + self.d0 = self.forward(self.var_ref, self.var_p0) + self.d1 = self.forward(self.var_ref, self.var_p1) + self.acc_r = self.compute_accuracy(self.d0,self.d1,self.input_judge) + + self.var_judge = Variable(1.*self.input_judge).view(self.d0.size()) + + self.loss_total = self.rankLoss.forward(self.d0, self.d1, self.var_judge*2.-1.) + + return self.loss_total + + def backward_train(self): + torch.mean(self.loss_total).backward() + + def compute_accuracy(self,d0,d1,judge): + ''' d0, d1 are Variables, judge is a Tensor ''' + d1_lt_d0 = (d1 %f' % (type,self.old_lr, lr)) + self.old_lr = lr + +def score_2afc_dataset(data_loader, func, name=''): + ''' Function computes Two Alternative Forced Choice (2AFC) score using + distance function 'func' in dataset 'data_loader' + INPUTS + data_loader - CustomDatasetDataLoader object - contains a TwoAFCDataset inside + func - callable distance function - calling d=func(in0,in1) should take 2 + pytorch tensors with shape Nx3xXxY, and return numpy array of length N + OUTPUTS + [0] - 2AFC score in [0,1], fraction of time func agrees with human evaluators + [1] - dictionary with following elements + d0s,d1s - N arrays containing distances between reference patch to perturbed patches + gts - N array in [0,1], preferred patch selected by human evaluators + (closer to "0" for left patch p0, "1" for right patch p1, + "0.6" means 60pct people preferred right patch, 40pct preferred left) + scores - N array in [0,1], corresponding to what percentage function agreed with humans + CONSTS + N - number of test triplets in data_loader + ''' + + d0s = [] + d1s = [] + gts = [] + + for data in tqdm(data_loader.load_data(), desc=name): + d0s+=func(data['ref'],data['p0']).data.cpu().numpy().flatten().tolist() + d1s+=func(data['ref'],data['p1']).data.cpu().numpy().flatten().tolist() + gts+=data['judge'].cpu().numpy().flatten().tolist() + + d0s = np.array(d0s) + d1s = np.array(d1s) + gts = np.array(gts) + scores = (d0s 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 = F.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 ScaledLeakyReLU(nn.Module): + def __init__(self, negative_slope=0.2): + super().__init__() + + self.negative_slope = negative_slope + + def forward(self, input): + out = F.leaky_relu(input, negative_slope=self.negative_slope) + + return out * math.sqrt(2) + + +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], + ): + 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 + + 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 + + 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 = F.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 = F.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 = F.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 + +# Wrapper that gives name to tensor +class NamedTensor(nn.Module): + def __init__(self): + super().__init__() + + def forward(self, x): + return x + +# Give each style a unique name +class StridedStyle(nn.ModuleList): + def __init__(self, n_latents): + super().__init__([NamedTensor() for _ in range(n_latents)]) + self.n_latents = n_latents + + def forward(self, x): + # x already strided + styles = [self[i](x[:, i, :]) for i in range(self.n_latents)] + return torch.stack(styles, dim=1) + +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)) + 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 + self.strided_style = StridedStyle(self.n_latent) + + 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_w=False, + noise=None, + randomize_noise=True, + ): + if not input_is_w: + 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) == 1: + # One global latent + inject_index = self.n_latent + + if styles[0].ndim < 3: + latent = styles[0].unsqueeze(1).repeat(1, inject_index, 1) + + else: + latent = styles[0] + + elif len(styles) == 2: + # Latent mixing with two latents + 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 = self.strided_style(torch.cat([latent, latent2], 1)) + else: + # One latent per layer + assert len(styles) == self.n_latent, f'Expected {self.n_latents} latents, got {len(styles)}' + styles = torch.stack(styles, dim=1) # [N, 18, 512] + latent = self.strided_style(styles) + + 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 + + +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: + if bias: + layers.append(FusedLeakyReLU(out_channel)) + + else: + layers.append(ScaledLeakyReLU(0.2)) + + 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/models/stylegan2/stylegan2-pytorch/non_leaking.py b/models/stylegan2/stylegan2-pytorch/non_leaking.py new file mode 100644 index 0000000000000000000000000000000000000000..4e044f98e836ae2c011ea91246b304d5ab1a1422 --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/non_leaking.py @@ -0,0 +1,137 @@ +import math + +import torch +from torch.nn import functional as F + + +def translate_mat(t_x, t_y): + batch = t_x.shape[0] + + mat = torch.eye(3).unsqueeze(0).repeat(batch, 1, 1) + translate = torch.stack((t_x, t_y), 1) + mat[:, :2, 2] = translate + + return mat + + +def rotate_mat(theta): + batch = theta.shape[0] + + mat = torch.eye(3).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): + batch = s_x.shape[0] + + mat = torch.eye(3).unsqueeze(0).repeat(batch, 1, 1) + mat[:, 0, 0] = s_x + mat[:, 1, 1] = s_y + + return mat + + +def lognormal_sample(size, mean=0, std=1): + return torch.empty(size).log_normal_(mean=mean, std=std) + + +def category_sample(size, categories): + category = torch.tensor(categories) + sample = torch.randint(high=len(categories), size=(size,)) + + return category[sample] + + +def uniform_sample(size, low, high): + return torch.empty(size).uniform_(low, high) + + +def normal_sample(size, mean=0, std=1): + return torch.empty(size).normal_(mean, std) + + +def bernoulli_sample(size, p): + return torch.empty(size).bernoulli_(p) + + +def random_affine_apply(p, transform, prev, eye): + size = transform.shape[0] + select = bernoulli_sample(size, p).view(size, 1, 1) + select_transform = select * transform + (1 - select) * eye + + return select_transform @ prev + + +def sample_affine(p, size, height, width): + G = torch.eye(3).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)) + G = random_affine_apply(p, Gc, G, eye) + # 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) + G = random_affine_apply(p, Gc, G, eye) + # 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) + G = random_affine_apply(p, Gc, G, eye) + # 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) + G = random_affine_apply(p, Gc, G, eye) + # 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) + G = random_affine_apply(p_rot, Gc, G, eye) + # 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) + G = random_affine_apply(p, Gc, G, eye) + # 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) + G = random_affine_apply(p_rot, Gc, G, eye) + # print('post-rotate', G, rotate_mat(-param), sep='\n') + + # fractional translate + param = normal_sample(size, std=0.125) + Gc = translate_mat(param, param) + G = random_affine_apply(p, Gc, G, eye) + # print('fractional translate', G, translate_mat(param, param), sep='\n') + + return G + + +def apply_affine(img, G): + grid = F.affine_grid( + torch.inverse(G).to(img)[:, :2, :], img.shape, align_corners=False + ) + img_affine = F.grid_sample( + img, grid, mode="bilinear", align_corners=False, padding_mode="reflection" + ) + + return img_affine diff --git a/models/stylegan2/stylegan2-pytorch/op/__init__.py b/models/stylegan2/stylegan2-pytorch/op/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d0918d92285955855be89f00096b888ee5597ce3 --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/op/__init__.py @@ -0,0 +1,2 @@ +from .fused_act import FusedLeakyReLU, fused_leaky_relu +from .upfirdn2d import upfirdn2d diff --git a/models/stylegan2/stylegan2-pytorch/op/__pycache__/__init__.cpython-310.pyc b/models/stylegan2/stylegan2-pytorch/op/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9e82b427cab68b67efd4878433862d124cae439f Binary files /dev/null and b/models/stylegan2/stylegan2-pytorch/op/__pycache__/__init__.cpython-310.pyc differ diff --git a/models/stylegan2/stylegan2-pytorch/op/__pycache__/fused_act.cpython-310.pyc b/models/stylegan2/stylegan2-pytorch/op/__pycache__/fused_act.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..258d0526439d7166da5bde114fdbf9af7386ad4f Binary files /dev/null and b/models/stylegan2/stylegan2-pytorch/op/__pycache__/fused_act.cpython-310.pyc differ diff --git a/models/stylegan2/stylegan2-pytorch/op/__pycache__/upfirdn2d.cpython-310.pyc b/models/stylegan2/stylegan2-pytorch/op/__pycache__/upfirdn2d.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..27a46b056a896f0f22907df4959b36d75793e0e7 Binary files /dev/null and b/models/stylegan2/stylegan2-pytorch/op/__pycache__/upfirdn2d.cpython-310.pyc differ diff --git a/models/stylegan2/stylegan2-pytorch/op/fused_act.py b/models/stylegan2/stylegan2-pytorch/op/fused_act.py new file mode 100644 index 0000000000000000000000000000000000000000..7e3d464ae656920c6875bc877281cadb2eaa4105 --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/op/fused_act.py @@ -0,0 +1,92 @@ +import os +import platform + +import torch +from torch import nn +from torch.autograd import Function +import torch.nn.functional as F +from torch.utils.cpp_extension import load + +use_fallback = False + +# Try loading precompiled, otherwise use native fallback +try: + import fused +except ModuleNotFoundError as e: + print('StyleGAN2: Optimized CUDA op FusedLeakyReLU not available, using native PyTorch fallback.') + use_fallback = True + + +class FusedLeakyReLUFunctionBackward(Function): + @staticmethod + def forward(ctx, grad_output, out, 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, empty, out, 3, 1, negative_slope, scale + ) + + dim = [0] + + if grad_input.ndim > 2: + dim += list(range(2, grad_input.ndim)) + + grad_bias = grad_input.sum(dim).detach() + + 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 + + +class FusedLeakyReLUFunction(Function): + @staticmethod + def forward(ctx, input, bias, negative_slope, scale): + empty = input.new_empty(0) + 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.negative_slope, ctx.scale + ) + + return grad_input, grad_bias, None, None + + +class FusedLeakyReLU(nn.Module): + def __init__(self, channel, negative_slope=0.2, scale=2 ** 0.5): + super().__init__() + + self.bias = nn.Parameter(torch.zeros(channel)) + 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, negative_slope=0.2, scale=2 ** 0.5): + if use_fallback or input.device.type == 'cpu': + return scale * F.leaky_relu( + input + bias.view((1, -1)+(1,)*(input.ndim-2)), negative_slope=negative_slope + ) + else: + return FusedLeakyReLUFunction.apply(input, bias, negative_slope, scale) diff --git a/models/stylegan2/stylegan2-pytorch/op/fused_bias_act.cpp b/models/stylegan2/stylegan2-pytorch/op/fused_bias_act.cpp new file mode 100644 index 0000000000000000000000000000000000000000..02be898f970bcc8ea297867fcaa4e71b24b3d949 --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/op/fused_bias_act.cpp @@ -0,0 +1,21 @@ +#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_CUDA(input); + CHECK_CUDA(bias); + + 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/models/stylegan2/stylegan2-pytorch/op/fused_bias_act_kernel.cu b/models/stylegan2/stylegan2-pytorch/op/fused_bias_act_kernel.cu new file mode 100644 index 0000000000000000000000000000000000000000..c9fa56fea7ede7072dc8925cfb0148f136eb85b8 --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/op/fused_bias_act_kernel.cu @@ -0,0 +1,99 @@ +// 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(curDevice); + + 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/models/stylegan2/stylegan2-pytorch/op/setup.py b/models/stylegan2/stylegan2-pytorch/op/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..5b926d450579990c8f09b93cbc5ae4c06128ef8d --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/op/setup.py @@ -0,0 +1,33 @@ +from setuptools import setup +from torch.utils.cpp_extension import CUDAExtension, BuildExtension +from pathlib import Path + +# Usage: +# python setup.py install (or python setup.py bdist_wheel) +# NB: Windows: run from VS2017 x64 Native Tool Command Prompt + +rootdir = (Path(__file__).parent / '..' / 'op').resolve() + +setup( + name='upfirdn2d', + ext_modules=[ + CUDAExtension('upfirdn2d_op', + [str(rootdir / 'upfirdn2d.cpp'), str(rootdir / 'upfirdn2d_kernel.cu')], + ) + ], + cmdclass={ + 'build_ext': BuildExtension + } +) + +setup( + name='fused', + ext_modules=[ + CUDAExtension('fused', + [str(rootdir / 'fused_bias_act.cpp'), str(rootdir / 'fused_bias_act_kernel.cu')], + ) + ], + cmdclass={ + 'build_ext': BuildExtension + } +) \ No newline at end of file diff --git a/models/stylegan2/stylegan2-pytorch/op/upfirdn2d.cpp b/models/stylegan2/stylegan2-pytorch/op/upfirdn2d.cpp new file mode 100644 index 0000000000000000000000000000000000000000..d2e633dc896433c205e18bc3e455539192ff968e --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/op/upfirdn2d.cpp @@ -0,0 +1,23 @@ +#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_CUDA(input); + CHECK_CUDA(kernel); + + 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/models/stylegan2/stylegan2-pytorch/op/upfirdn2d.py b/models/stylegan2/stylegan2-pytorch/op/upfirdn2d.py new file mode 100644 index 0000000000000000000000000000000000000000..9ca1f5c72098debfb0ffa1ba1b81eb92eb64d428 --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/op/upfirdn2d.py @@ -0,0 +1,198 @@ +import os +import platform + +import torch +from torch.nn import functional as F +from torch.autograd import Function +from torch.utils.cpp_extension import load + +use_fallback = False + +# Try loading precompiled, otherwise use native fallback +try: + import upfirdn2d_op +except ModuleNotFoundError as e: + print('StyleGAN2: Optimized CUDA op UpFirDn2d not available, using native PyTorch fallback.') + use_fallback = True + +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 + 1 + out_w = (in_w * up_x + pad_x0 + pad_x1 - kernel_w) // down_x + 1 + 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 = 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 use_fallback or input.device.type == "cpu": + out = upfirdn2d_native( + input, kernel, up, up, down, down, pad[0], pad[1], pad[0], pad[1] + ) + else: + out = UpFirDn2d.apply( + input, kernel, (up, up), (down, down), (pad[0], pad[1], pad[0], pad[1]) + ) + + 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 + 1 + out_w = (in_w * up_x + pad_x0 + pad_x1 - kernel_w) // down_x + 1 + + return out.view(-1, channel, out_h, out_w) diff --git a/models/stylegan2/stylegan2-pytorch/op/upfirdn2d_kernel.cu b/models/stylegan2/stylegan2-pytorch/op/upfirdn2d_kernel.cu new file mode 100644 index 0000000000000000000000000000000000000000..a88bc7720da6cd54fccd0c4a03dd20fde85c063d --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/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(curDevice); + + 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/models/stylegan2/stylegan2-pytorch/ppl.py b/models/stylegan2/stylegan2-pytorch/ppl.py new file mode 100644 index 0000000000000000000000000000000000000000..6b185c894ba719701baa6ac348e743a003ec5f27 --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/ppl.py @@ -0,0 +1,104 @@ +import argparse + +import torch +from torch.nn import functional as F +import numpy as np +from tqdm import tqdm + +import lpips +from model import Generator + + +def normalize(x): + return x / torch.sqrt(x.pow(2).sum(-1, keepdim=True)) + + +def slerp(a, b, t): + a = normalize(a) + b = normalize(b) + d = (a * b).sum(-1, keepdim=True) + p = t * torch.acos(d) + c = normalize(b - d * a) + d = a * torch.cos(p) + c * torch.sin(p) + + return normalize(d) + + +def lerp(a, b, t): + return a + (b - a) * t + + +if __name__ == '__main__': + device = 'cuda' + + parser = argparse.ArgumentParser() + + parser.add_argument('--space', choices=['z', 'w']) + parser.add_argument('--batch', type=int, default=64) + parser.add_argument('--n_sample', type=int, default=5000) + parser.add_argument('--size', type=int, default=256) + parser.add_argument('--eps', type=float, default=1e-4) + parser.add_argument('--crop', action='store_true') + parser.add_argument('ckpt', metavar='CHECKPOINT') + + args = parser.parse_args() + + latent_dim = 512 + + ckpt = torch.load(args.ckpt) + + g = Generator(args.size, latent_dim, 8).to(device) + g.load_state_dict(ckpt['g_ema']) + g.eval() + + percept = lpips.PerceptualLoss( + model='net-lin', net='vgg', use_gpu=device.startswith('cuda') + ) + + distances = [] + + n_batch = args.n_sample // args.batch + resid = args.n_sample - (n_batch * args.batch) + batch_sizes = [args.batch] * n_batch + [resid] + + with torch.no_grad(): + for batch in tqdm(batch_sizes): + noise = g.make_noise() + + inputs = torch.randn([batch * 2, latent_dim], device=device) + lerp_t = torch.rand(batch, device=device) + + if args.space == 'w': + latent = g.get_latent(inputs) + latent_t0, latent_t1 = latent[::2], latent[1::2] + latent_e0 = lerp(latent_t0, latent_t1, lerp_t[:, None]) + latent_e1 = lerp(latent_t0, latent_t1, lerp_t[:, None] + args.eps) + latent_e = torch.stack([latent_e0, latent_e1], 1).view(*latent.shape) + + image, _ = g([latent_e], input_is_latent=True, noise=noise) + + if args.crop: + c = image.shape[2] // 8 + image = image[:, :, c * 3 : c * 7, c * 2 : c * 6] + + factor = image.shape[2] // 256 + + if factor > 1: + image = F.interpolate( + image, size=(256, 256), mode='bilinear', align_corners=False + ) + + dist = percept(image[::2], image[1::2]).view(image.shape[0] // 2) / ( + args.eps ** 2 + ) + distances.append(dist.to('cpu').numpy()) + + distances = np.concatenate(distances, 0) + + lo = np.percentile(distances, 1, interpolation='lower') + hi = np.percentile(distances, 99, interpolation='higher') + filtered_dist = np.extract( + np.logical_and(lo <= distances, distances <= hi), distances + ) + + print('ppl:', filtered_dist.mean()) diff --git a/models/stylegan2/stylegan2-pytorch/prepare_data.py b/models/stylegan2/stylegan2-pytorch/prepare_data.py new file mode 100644 index 0000000000000000000000000000000000000000..db49cbda14aca3b2bc0268a4f40cd97f2dd603cc --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/prepare_data.py @@ -0,0 +1,82 @@ +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 + + +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() + parser.add_argument('--out', type=str) + parser.add_argument('--size', type=str, default='128,256,512,1024') + parser.add_argument('--n_worker', type=int, default=8) + parser.add_argument('--resample', type=str, default='lanczos') + parser.add_argument('path', type=str) + + args = parser.parse_args() + + 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/models/stylegan2/stylegan2-pytorch/projector.py b/models/stylegan2/stylegan2-pytorch/projector.py new file mode 100644 index 0000000000000000000000000000000000000000..d63ad3573696cc22640cbeddc197d8cb15c52977 --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/projector.py @@ -0,0 +1,203 @@ +import argparse +import math +import os + +import torch +from torch import optim +from torch.nn import functional as F +from torchvision import transforms +from PIL import Image +from tqdm import tqdm + +import lpips +from model import Generator + + +def noise_regularize(noises): + loss = 0 + + for noise in noises: + size = noise.shape[2] + + while True: + loss = ( + loss + + (noise * torch.roll(noise, shifts=1, dims=3)).mean().pow(2) + + (noise * torch.roll(noise, shifts=1, dims=2)).mean().pow(2) + ) + + if size <= 8: + break + + noise = noise.reshape([1, 1, size // 2, 2, size // 2, 2]) + noise = noise.mean([3, 5]) + size //= 2 + + return loss + + +def noise_normalize_(noises): + for noise in noises: + mean = noise.mean() + std = noise.std() + + noise.data.add_(-mean).div_(std) + + +def get_lr(t, initial_lr, rampdown=0.25, rampup=0.05): + lr_ramp = min(1, (1 - t) / rampdown) + lr_ramp = 0.5 - 0.5 * math.cos(lr_ramp * math.pi) + lr_ramp = lr_ramp * min(1, t / rampup) + + return initial_lr * lr_ramp + + +def latent_noise(latent, strength): + noise = torch.randn_like(latent) * strength + + return latent + noise + + +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() + ) + + +if __name__ == '__main__': + device = 'cuda' + + parser = argparse.ArgumentParser() + parser.add_argument('--ckpt', type=str, required=True) + parser.add_argument('--size', type=int, default=256) + parser.add_argument('--lr_rampup', type=float, default=0.05) + parser.add_argument('--lr_rampdown', type=float, default=0.25) + parser.add_argument('--lr', type=float, default=0.1) + parser.add_argument('--noise', type=float, default=0.05) + parser.add_argument('--noise_ramp', type=float, default=0.75) + parser.add_argument('--step', type=int, default=1000) + parser.add_argument('--noise_regularize', type=float, default=1e5) + parser.add_argument('--mse', type=float, default=0) + parser.add_argument('--w_plus', action='store_true') + parser.add_argument('files', metavar='FILES', nargs='+') + + args = parser.parse_args() + + n_mean_latent = 10000 + + resize = min(args.size, 256) + + transform = transforms.Compose( + [ + transforms.Resize(resize), + transforms.CenterCrop(resize), + transforms.ToTensor(), + transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]), + ] + ) + + imgs = [] + + for imgfile in args.files: + img = transform(Image.open(imgfile).convert('RGB')) + imgs.append(img) + + imgs = torch.stack(imgs, 0).to(device) + + g_ema = Generator(args.size, 512, 8) + g_ema.load_state_dict(torch.load(args.ckpt)['g_ema'], strict=False) + g_ema.eval() + g_ema = g_ema.to(device) + + with torch.no_grad(): + noise_sample = torch.randn(n_mean_latent, 512, device=device) + latent_out = g_ema.style(noise_sample) + + latent_mean = latent_out.mean(0) + latent_std = ((latent_out - latent_mean).pow(2).sum() / n_mean_latent) ** 0.5 + + percept = lpips.PerceptualLoss( + model='net-lin', net='vgg', use_gpu=device.startswith('cuda') + ) + + noises = g_ema.make_noise() + + latent_in = latent_mean.detach().clone().unsqueeze(0).repeat(2, 1) + + if args.w_plus: + latent_in = latent_in.unsqueeze(1).repeat(1, g_ema.n_latent, 1) + + latent_in.requires_grad = True + + for noise in noises: + noise.requires_grad = True + + optimizer = optim.Adam([latent_in] + noises, lr=args.lr) + + pbar = tqdm(range(args.step)) + latent_path = [] + + for i in pbar: + t = i / args.step + lr = get_lr(t, args.lr) + optimizer.param_groups[0]['lr'] = lr + noise_strength = latent_std * args.noise * max(0, 1 - t / args.noise_ramp) ** 2 + latent_n = latent_noise(latent_in, noise_strength.item()) + + img_gen, _ = g_ema([latent_n], input_is_latent=True, noise=noises) + + batch, channel, height, width = img_gen.shape + + if height > 256: + factor = height // 256 + + img_gen = img_gen.reshape( + batch, channel, height // factor, factor, width // factor, factor + ) + img_gen = img_gen.mean([3, 5]) + + p_loss = percept(img_gen, imgs).sum() + n_loss = noise_regularize(noises) + mse_loss = F.mse_loss(img_gen, imgs) + + loss = p_loss + args.noise_regularize * n_loss + args.mse * mse_loss + + optimizer.zero_grad() + loss.backward() + optimizer.step() + + noise_normalize_(noises) + + if (i + 1) % 100 == 0: + latent_path.append(latent_in.detach().clone()) + + pbar.set_description( + ( + f'perceptual: {p_loss.item():.4f}; noise regularize: {n_loss.item():.4f};' + f' mse: {mse_loss.item():.4f}; lr: {lr:.4f}' + ) + ) + + result_file = {'noises': noises} + + img_gen, _ = g_ema([latent_path[-1]], input_is_latent=True, noise=noises) + + filename = os.path.splitext(os.path.basename(args.files[0]))[0] + '.pt' + + img_ar = make_image(img_gen) + + for i, input_name in enumerate(args.files): + result_file[input_name] = {'img': img_gen[i], 'latent': latent_in[i]} + img_name = os.path.splitext(os.path.basename(input_name))[0] + '-project.png' + pil_img = Image.fromarray(img_ar[i]) + pil_img.save(img_name) + + torch.save(result_file, filename) diff --git a/models/stylegan2/stylegan2-pytorch/sample/.gitignore b/models/stylegan2/stylegan2-pytorch/sample/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..e33609d251c814ccd3a30337c965a875645c2117 --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/sample/.gitignore @@ -0,0 +1 @@ +*.png diff --git a/models/stylegan2/stylegan2-pytorch/train.py b/models/stylegan2/stylegan2-pytorch/train.py new file mode 100644 index 0000000000000000000000000000000000000000..7295f159b0427aef89a5944a0d1eb4c23ee85a7f --- /dev/null +++ b/models/stylegan2/stylegan2-pytorch/train.py @@ -0,0 +1,413 @@ +import argparse +import math +import random +import os + +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 + +try: + import wandb + +except ImportError: + wandb = None + +from model import Generator, Discriminator +from dataset import MultiResolutionDataset +from distributed import ( + get_rank, + synchronize, + reduce_loss_dict, + reduce_sum, + get_world_size, +) + + +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_(1 - decay, par2[k].data) + + +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): + grad_real, = autograd.grad( + outputs=real_pred.sum(), inputs=real_img, create_graph=True + ) + grad_penalty = grad_real.pow(2).view(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, 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 = {} + + if args.distributed: + g_module = generator.module + d_module = discriminator.module + + else: + g_module = generator + d_module = discriminator + + accum = 0.5 ** (32 / (10 * 1000)) + + sample_z = torch.randn(args.n_sample, args.latent, device=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) + fake_pred = discriminator(fake_img) + + real_pred = discriminator(real_img) + 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() + + d_regularize = i % args.d_reg_every == 0 + + if d_regularize: + real_img.requires_grad = True + real_pred = discriminator(real_img) + 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) + fake_pred = discriminator(fake_img) + g_loss = g_nonsaturating_loss(fake_pred) + + 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}" + ) + ) + + if wandb and args.wandb: + wandb.log( + { + "Generator": g_loss_val, + "Discriminator": d_loss_val, + "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 % 100 == 0: + with torch.no_grad(): + g_ema.eval() + sample, _ = g_ema([sample_z]) + utils.save_image( + sample, + f"sample/{str(i).zfill(6)}.png", + nrow=int(args.n_sample ** 0.5), + normalize=True, + range=(-1, 1), + ) + + if i % 10000 == 0: + 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(), + }, + f"checkpoint/{str(i).zfill(6)}.pt", + ) + + +if __name__ == "__main__": + device = "cuda" + + parser = argparse.ArgumentParser() + + parser.add_argument("path", type=str) + parser.add_argument("--iter", type=int, default=800000) + parser.add_argument("--batch", type=int, default=16) + parser.add_argument("--n_sample", type=int, default=64) + parser.add_argument("--size", type=int, default=256) + parser.add_argument("--r1", type=float, default=10) + parser.add_argument("--path_regularize", type=float, default=2) + parser.add_argument("--path_batch_shrink", type=int, default=2) + parser.add_argument("--d_reg_every", type=int, default=16) + parser.add_argument("--g_reg_every", type=int, default=4) + parser.add_argument("--mixing", type=float, default=0.9) + parser.add_argument("--ckpt", type=str, default=None) + parser.add_argument("--lr", type=float, default=0.002) + parser.add_argument("--channel_multiplier", type=int, default=2) + parser.add_argument("--wandb", action="store_true") + parser.add_argument("--local_rank", type=int, default=0) + + args = parser.parse_args() + + 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 + + generator = Generator( + args.size, args.latent, args.n_mlp, channel_multiplier=args.channel_multiplier + ).to(device) + 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"]) + 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, discriminator, g_optim, d_optim, g_ema, device) diff --git a/models/wrappers.py b/models/wrappers.py new file mode 100644 index 0000000000000000000000000000000000000000..30c5a9e13fffca026e856dcbe972269961c46fc2 --- /dev/null +++ b/models/wrappers.py @@ -0,0 +1,737 @@ +# Copyright 2020 Erik Härkönen. All rights reserved. +# This file is licensed to you under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. You may obtain a copy +# of the License at http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software distributed under +# the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS +# OF ANY KIND, either express or implied. See the License for the specific language +# governing permissions and limitations under the License. + +import torch +import numpy as np +import re +import os +import random +from pathlib import Path +from types import SimpleNamespace +from utils import download_ckpt +from config import Config +from netdissect import proggan, zdataset +from . import biggan +from . import stylegan +from . import stylegan2 +from abc import abstractmethod, ABC as AbstractBaseClass +from functools import singledispatch + +class BaseModel(AbstractBaseClass, torch.nn.Module): + + # Set parameters for identifying model from instance + def __init__(self, model_name, class_name): + super(BaseModel, self).__init__() + self.model_name = model_name + self.outclass = class_name + + # Stop model evaluation as soon as possible after + # given layer has been executed, used to speed up + # netdissect.InstrumentedModel::retain_layer(). + # Validate with tests/partial_forward_test.py + # Can use forward() as fallback at the cost of performance. + @abstractmethod + def partial_forward(self, x, layer_name): + pass + + # Generate batch of latent vectors + @abstractmethod + def sample_latent(self, n_samples=1, seed=None, truncation=None): + pass + + # Maximum number of latents that can be provided + # Typically one for each layer + def get_max_latents(self): + return 1 + + # Name of primary latent space + # E.g. StyleGAN can alternatively use W + def latent_space_name(self): + return 'Z' + + def get_latent_shape(self): + return tuple(self.sample_latent(1).shape) + + def get_latent_dims(self): + return np.prod(self.get_latent_shape()) + + def set_output_class(self, new_class): + self.outclass = new_class + + # Map from typical range [-1, 1] to [0, 1] + def forward(self, x): + out = self.model.forward(x) + return 0.5*(out+1) + + # Generate images + def sample(self, z=None, n_samples=1, seed=None): + if z is None: + z = self.sample_latent(n_samples, seed=seed) + elif isinstance(z, list): + z = [torch.tensor(l).to(self.device) if not torch.is_tensor(l) else l for l in z] + elif not torch.is_tensor(z): + z = torch.tensor(z).to(self.device) + img = self.forward(z) + return img + + + # For models that use part of latent as conditioning + def get_conditional_state(self, z): + return None + + # For models that use part of latent as conditioning + def set_conditional_state(self, z, c): + return z + + def named_modules(self, *args, **kwargs): + return self.model.named_modules(*args, **kwargs) + +# PyTorch port of StyleGAN 2 +class StyleGAN2(BaseModel): + def __init__(self, device, class_name, truncation=1.0, use_w=False): + super(StyleGAN2, self).__init__('StyleGAN2', class_name or 'ffhq') + self.device = device + self.truncation = truncation + self.latent_avg = None + self.w_primary = use_w # use W as primary latent space? + + # Image widths + configs = { + # Converted NVIDIA official + 'ffhq': 1024, + 'car': 512, + 'cat': 256, + 'church': 256, + 'horse': 256, + # Tuomas + 'bedrooms': 256, + 'kitchen': 256, + 'places': 256, + 'lookbook': 512 + } + + assert self.outclass in configs, \ + f'Invalid StyleGAN2 class {self.outclass}, should be one of [{", ".join(configs.keys())}]' + + self.resolution = configs[self.outclass] + self.name = f'StyleGAN2-{self.outclass}' + self.has_latent_residual = True + self.load_model() + self.set_noise_seed(0) + + def latent_space_name(self): + return 'W' if self.w_primary else 'Z' + + def use_w(self): + self.w_primary = True + + def use_z(self): + self.w_primary = False + + # URLs created with https://sites.google.com/site/gdocs2direct/ + def download_checkpoint(self, outfile): + checkpoints = { + 'horse': 'https://drive.google.com/uc?export=download&id=18SkqWAkgt0fIwDEf2pqeaenNi4OoCo-0', + 'ffhq': 'https://drive.google.com/uc?export=download&id=1FJRwzAkV-XWbxgTwxEmEACvuqF5DsBiV', + 'church': 'https://drive.google.com/uc?export=download&id=1HFM694112b_im01JT7wop0faftw9ty5g', + 'car': 'https://drive.google.com/uc?export=download&id=1iRoWclWVbDBAy5iXYZrQnKYSbZUqXI6y', + 'cat': 'https://drive.google.com/uc?export=download&id=15vJP8GDr0FlRYpE8gD7CdeEz2mXrQMgN', + 'places': 'https://drive.google.com/uc?export=download&id=1X8-wIH3aYKjgDZt4KMOtQzN1m4AlCVhm', + 'bedrooms': 'https://drive.google.com/uc?export=download&id=1nZTW7mjazs-qPhkmbsOLLA_6qws-eNQu', + 'kitchen': 'https://drive.google.com/uc?export=download&id=15dCpnZ1YLAnETAPB0FGmXwdBclbwMEkZ', + 'lookbook': 'https://github.com/prathmeshdahikar/FashionGen/releases/download/v1.0/stylegan2_lookbook_512.pt' + } + + url = checkpoints[self.outclass] + download_ckpt(url, outfile) + + def load_model(self): + checkpoint_root = os.environ.get('GANCONTROL_CHECKPOINT_DIR', Path(__file__).parent / 'checkpoints') + checkpoint = Path(checkpoint_root) / f'stylegan2/stylegan2_{self.outclass}_{self.resolution}.pt' + + self.model = stylegan2.Generator(self.resolution, 512, 8).to(self.device) + + if not checkpoint.is_file(): + os.makedirs(checkpoint.parent, exist_ok=True) + self.download_checkpoint(checkpoint) + + ckpt = torch.load(checkpoint) + self.model.load_state_dict(ckpt['g_ema'], strict=False) + self.latent_avg = 0 + + def sample_latent(self, n_samples=1, seed=None, truncation=None): + if seed is None: + seed = np.random.randint(np.iinfo(np.int32).max) # use (reproducible) global rand state + + rng = np.random.RandomState(seed) + z = torch.from_numpy( + rng.standard_normal(512 * n_samples) + .reshape(n_samples, 512)).float().to(self.device) #[N, 512] + + if self.w_primary: + z = self.model.style(z) + + return z + + def get_max_latents(self): + return self.model.n_latent + + def set_output_class(self, new_class): + if self.outclass != new_class: + raise RuntimeError('StyleGAN2: cannot change output class without reloading') + + def forward(self, x): + x = x if isinstance(x, list) else [x] + out, _ = self.model(x, noise=self.noise, + truncation=self.truncation, truncation_latent=self.latent_avg, input_is_w=self.w_primary) + return 0.5*(out+1) + + def partial_forward(self, x, layer_name): + styles = x if isinstance(x, list) else [x] + inject_index = None + noise = self.noise + + if not self.w_primary: + styles = [self.model.style(s) for s in styles] + + if len(styles) == 1: + # One global latent + inject_index = self.model.n_latent + latent = self.model.strided_style(styles[0].unsqueeze(1).repeat(1, inject_index, 1)) # [N, 18, 512] + elif len(styles) == 2: + # Latent mixing with two latents + if inject_index is None: + inject_index = random.randint(1, self.model.n_latent - 1) + + latent = styles[0].unsqueeze(1).repeat(1, inject_index, 1) + latent2 = styles[1].unsqueeze(1).repeat(1, self.model.n_latent - inject_index, 1) + + latent = self.model.strided_style(torch.cat([latent, latent2], 1)) + else: + # One latent per layer + assert len(styles) == self.model.n_latent, f'Expected {self.model.n_latents} latents, got {len(styles)}' + styles = torch.stack(styles, dim=1) # [N, 18, 512] + latent = self.model.strided_style(styles) + + if 'style' in layer_name: + return + + out = self.model.input(latent) + if 'input' == layer_name: + return + + out = self.model.conv1(out, latent[:, 0], noise=noise[0]) + if 'conv1' in layer_name: + return + + skip = self.model.to_rgb1(out, latent[:, 1]) + if 'to_rgb1' in layer_name: + return + + i = 1 + noise_i = 1 + + for conv1, conv2, to_rgb in zip( + self.model.convs[::2], self.model.convs[1::2], self.model.to_rgbs + ): + out = conv1(out, latent[:, i], noise=noise[noise_i]) + if f'convs.{i-1}' in layer_name: + return + + out = conv2(out, latent[:, i + 1], noise=noise[noise_i + 1]) + if f'convs.{i}' in layer_name: + return + + skip = to_rgb(out, latent[:, i + 2], skip) + if f'to_rgbs.{i//2}' in layer_name: + return + + i += 2 + noise_i += 2 + + image = skip + + raise RuntimeError(f'Layer {layer_name} not encountered in partial_forward') + + def set_noise_seed(self, seed): + torch.manual_seed(seed) + self.noise = [torch.randn(1, 1, 2 ** 2, 2 ** 2, device=self.device)] + + for i in range(3, self.model.log_size + 1): + for _ in range(2): + self.noise.append(torch.randn(1, 1, 2 ** i, 2 ** i, device=self.device)) + +# PyTorch port of StyleGAN 1 +class StyleGAN(BaseModel): + def __init__(self, device, class_name, truncation=1.0, use_w=False): + super(StyleGAN, self).__init__('StyleGAN', class_name or 'ffhq') + self.device = device + self.w_primary = use_w # is W primary latent space? + + configs = { + # Official + 'ffhq': 1024, + 'celebahq': 1024, + 'bedrooms': 256, + 'cars': 512, + 'cats': 256, + + # From https://github.com/justinpinkney/awesome-pretrained-stylegan + 'vases': 1024, + 'wikiart': 512, + 'fireworks': 512, + 'abstract': 512, + 'anime': 512, + 'ukiyo-e': 512, + } + + assert self.outclass in configs, \ + f'Invalid StyleGAN class {self.outclass}, should be one of [{", ".join(configs.keys())}]' + + self.resolution = configs[self.outclass] + self.name = f'StyleGAN-{self.outclass}' + self.has_latent_residual = True + self.load_model() + self.set_noise_seed(0) + + def latent_space_name(self): + return 'W' if self.w_primary else 'Z' + + def use_w(self): + self.w_primary = True + + def use_z(self): + self.w_primary = False + + def load_model(self): + checkpoint_root = os.environ.get('GANCONTROL_CHECKPOINT_DIR', Path(__file__).parent / 'checkpoints') + checkpoint = Path(checkpoint_root) / f'stylegan/stylegan_{self.outclass}_{self.resolution}.pt' + + self.model = stylegan.StyleGAN_G(self.resolution).to(self.device) + + urls_tf = { + 'vases': 'https://thisvesseldoesnotexist.s3-us-west-2.amazonaws.com/public/network-snapshot-008980.pkl', + 'fireworks': 'https://mega.nz/#!7uBHnACY!quIW-pjdDa7NqnZOYh1z5UemWwPOW6HkYSoJ4usCg9U', + 'abstract': 'https://mega.nz/#!vCQyHQZT!zdeOg3VvT4922Z2UfxO51xgAfJD-NAK2nW7H_jMlilU', + 'anime': 'https://mega.nz/#!vawjXISI!F7s13yRicxDA3QYqYDL2kjnc2K7Zk3DwCIYETREmBP4', + 'ukiyo-e': 'https://drive.google.com/uc?id=1CHbJlci9NhVFifNQb3vCGu6zw4eqzvTd', + } + + urls_torch = { + 'celebahq': 'https://drive.google.com/uc?export=download&id=1lGcRwNoXy_uwXkD6sy43aAa-rMHRR7Ad', + 'bedrooms': 'https://drive.google.com/uc?export=download&id=1r0_s83-XK2dKlyY3WjNYsfZ5-fnH8QgI', + 'ffhq': 'https://drive.google.com/uc?export=download&id=1GcxTcLDPYxQqcQjeHpLUutGzwOlXXcks', + 'cars': 'https://drive.google.com/uc?export=download&id=1aaUXHRHjQ9ww91x4mtPZD0w50fsIkXWt', + 'cats': 'https://drive.google.com/uc?export=download&id=1JzA5iiS3qPrztVofQAjbb0N4xKdjOOyV', + 'wikiart': 'https://drive.google.com/uc?export=download&id=1fN3noa7Rsl9slrDXsgZVDsYFxV0O08Vx', + } + + if not checkpoint.is_file(): + os.makedirs(checkpoint.parent, exist_ok=True) + if self.outclass in urls_torch: + download_ckpt(urls_torch[self.outclass], checkpoint) + else: + checkpoint_tf = checkpoint.with_suffix('.pkl') + if not checkpoint_tf.is_file(): + download_ckpt(urls_tf[self.outclass], checkpoint_tf) + print('Converting TensorFlow checkpoint to PyTorch') + self.model.export_from_tf(checkpoint_tf) + + self.model.load_weights(checkpoint) + + def sample_latent(self, n_samples=1, seed=None, truncation=None): + if seed is None: + seed = np.random.randint(np.iinfo(np.int32).max) # use (reproducible) global rand state + + rng = np.random.RandomState(seed) + noise = torch.from_numpy( + rng.standard_normal(512 * n_samples) + .reshape(n_samples, 512)).float().to(self.device) #[N, 512] + + if self.w_primary: + noise = self.model._modules['g_mapping'].forward(noise) + + return noise + + def get_max_latents(self): + return 18 + + def set_output_class(self, new_class): + if self.outclass != new_class: + raise RuntimeError('StyleGAN: cannot change output class without reloading') + + def forward(self, x): + out = self.model.forward(x, latent_is_w=self.w_primary) + return 0.5*(out+1) + + # Run model only until given layer + def partial_forward(self, x, layer_name): + mapping = self.model._modules['g_mapping'] + G = self.model._modules['g_synthesis'] + trunc = self.model._modules.get('truncation', lambda x : x) + + if not self.w_primary: + x = mapping.forward(x) # handles list inputs + + if isinstance(x, list): + x = torch.stack(x, dim=1) + else: + x = x.unsqueeze(1).expand(-1, 18, -1) + + # Whole mapping + if 'g_mapping' in layer_name: + return + + x = trunc(x) + if layer_name == 'truncation': + return + + # Get names of children + def iterate(m, name, seen): + children = getattr(m, '_modules', []) + if len(children) > 0: + for child_name, module in children.items(): + seen += iterate(module, f'{name}.{child_name}', seen) + return seen + else: + return [name] + + # Generator + batch_size = x.size(0) + for i, (n, m) in enumerate(G.blocks.items()): # InputBlock or GSynthesisBlock + if i == 0: + r = m(x[:, 2*i:2*i+2]) + else: + r = m(r, x[:, 2*i:2*i+2]) + + children = iterate(m, f'g_synthesis.blocks.{n}', []) + for c in children: + if layer_name in c: # substring + return + + raise RuntimeError(f'Layer {layer_name} not encountered in partial_forward') + + + def set_noise_seed(self, seed): + G = self.model._modules['g_synthesis'] + + def for_each_child(this, name, func): + children = getattr(this, '_modules', []) + for child_name, module in children.items(): + for_each_child(module, f'{name}.{child_name}', func) + func(this, name) + + def modify(m, name): + if isinstance(m, stylegan.NoiseLayer): + H, W = [int(s) for s in name.split('.')[2].split('x')] + torch.random.manual_seed(seed) + m.noise = torch.randn(1, 1, H, W, device=self.device, dtype=torch.float32) + #m.noise = 1.0 # should be [N, 1, H, W], but this also works + + for_each_child(G, 'g_synthesis', modify) + +class GANZooModel(BaseModel): + def __init__(self, device, model_name): + super(GANZooModel, self).__init__(model_name, 'default') + self.device = device + self.base_model = torch.hub.load('facebookresearch/pytorch_GAN_zoo:hub', + model_name, pretrained=True, useGPU=(device.type == 'cuda')) + self.model = self.base_model.netG.to(self.device) + self.name = model_name + self.has_latent_residual = False + + def sample_latent(self, n_samples=1, seed=0, truncation=None): + # Uses torch.randn + noise, _ = self.base_model.buildNoiseData(n_samples) + return noise + + # Don't bother for now + def partial_forward(self, x, layer_name): + return self.forward(x) + + def get_conditional_state(self, z): + return z[:, -20:] # last 20 = conditioning + + def set_conditional_state(self, z, c): + z[:, -20:] = c + return z + + def forward(self, x): + out = self.base_model.test(x) + return 0.5*(out+1) + + +class ProGAN(BaseModel): + def __init__(self, device, lsun_class=None): + super(ProGAN, self).__init__('ProGAN', lsun_class) + self.device = device + + # These are downloaded by GANDissect + valid_classes = [ 'bedroom', 'churchoutdoor', 'conferenceroom', 'diningroom', 'kitchen', 'livingroom', 'restaurant' ] + assert self.outclass in valid_classes, \ + f'Invalid LSUN class {self.outclass}, should be one of {valid_classes}' + + self.load_model() + self.name = f'ProGAN-{self.outclass}' + self.has_latent_residual = False + + def load_model(self): + checkpoint_root = os.environ.get('GANCONTROL_CHECKPOINT_DIR', Path(__file__).parent / 'checkpoints') + checkpoint = Path(checkpoint_root) / f'progan/{self.outclass}_lsun.pth' + + if not checkpoint.is_file(): + os.makedirs(checkpoint.parent, exist_ok=True) + url = f'http://netdissect.csail.mit.edu/data/ganmodel/karras/{self.outclass}_lsun.pth' + download_ckpt(url, checkpoint) + + self.model = proggan.from_pth_file(str(checkpoint.resolve())).to(self.device) + + def sample_latent(self, n_samples=1, seed=None, truncation=None): + if seed is None: + seed = np.random.randint(np.iinfo(np.int32).max) # use (reproducible) global rand state + noise = zdataset.z_sample_for_model(self.model, n_samples, seed=seed)[...] + return noise.to(self.device) + + def forward(self, x): + if isinstance(x, list): + assert len(x) == 1, "ProGAN only supports a single global latent" + x = x[0] + + out = self.model.forward(x) + return 0.5*(out+1) + + # Run model only until given layer + def partial_forward(self, x, layer_name): + assert isinstance(self.model, torch.nn.Sequential), 'Expected sequential model' + + if isinstance(x, list): + assert len(x) == 1, "ProGAN only supports a single global latent" + x = x[0] + + x = x.view(x.shape[0], x.shape[1], 1, 1) + for name, module in self.model._modules.items(): # ordered dict + x = module(x) + if name == layer_name: + return + + raise RuntimeError(f'Layer {layer_name} not encountered in partial_forward') + + +class BigGAN(BaseModel): + def __init__(self, device, resolution, class_name, truncation=1.0): + super(BigGAN, self).__init__(f'BigGAN-{resolution}', class_name) + self.device = device + self.truncation = truncation + self.load_model(f'biggan-deep-{resolution}') + self.set_output_class(class_name or 'husky') + self.name = f'BigGAN-{resolution}-{self.outclass}-t{self.truncation}' + self.has_latent_residual = True + + # Default implementaiton fails without an internet + # connection, even if the model has been cached + def load_model(self, name): + if name not in biggan.model.PRETRAINED_MODEL_ARCHIVE_MAP: + raise RuntimeError('Unknown BigGAN model name', name) + + checkpoint_root = os.environ.get('GANCONTROL_CHECKPOINT_DIR', Path(__file__).parent / 'checkpoints') + model_path = Path(checkpoint_root) / name + + os.makedirs(model_path, exist_ok=True) + + model_file = model_path / biggan.model.WEIGHTS_NAME + config_file = model_path / biggan.model.CONFIG_NAME + model_url = biggan.model.PRETRAINED_MODEL_ARCHIVE_MAP[name] + config_url = biggan.model.PRETRAINED_CONFIG_ARCHIVE_MAP[name] + + for filename, url in ((model_file, model_url), (config_file, config_url)): + if not filename.is_file(): + print('Downloading', url) + with open(filename, 'wb') as f: + if url.startswith("s3://"): + biggan.s3_get(url, f) + else: + biggan.http_get(url, f) + + self.model = biggan.BigGAN.from_pretrained(model_path).to(self.device) + + def sample_latent(self, n_samples=1, truncation=None, seed=None): + if seed is None: + seed = np.random.randint(np.iinfo(np.int32).max) # use (reproducible) global rand state + + noise_vector = biggan.truncated_noise_sample(truncation=truncation or self.truncation, batch_size=n_samples, seed=seed) + noise = torch.from_numpy(noise_vector) #[N, 128] + + return noise.to(self.device) + + # One extra for gen_z + def get_max_latents(self): + return len(self.model.config.layers) + 1 + + def get_conditional_state(self, z): + return self.v_class + + def set_conditional_state(self, z, c): + self.v_class = c + + def is_valid_class(self, class_id): + if isinstance(class_id, int): + return class_id < 1000 + elif isinstance(class_id, str): + return biggan.one_hot_from_names([class_id.replace(' ', '_')]) is not None + else: + raise RuntimeError(f'Unknown class identifier {class_id}') + + def set_output_class(self, class_id): + if isinstance(class_id, int): + self.v_class = torch.from_numpy(biggan.one_hot_from_int([class_id])).to(self.device) + self.outclass = f'class{class_id}' + elif isinstance(class_id, str): + self.outclass = class_id.replace(' ', '_') + self.v_class = torch.from_numpy(biggan.one_hot_from_names([class_id])).to(self.device) + else: + raise RuntimeError(f'Unknown class identifier {class_id}') + + def forward(self, x): + # Duplicate along batch dimension + if isinstance(x, list): + c = self.v_class.repeat(x[0].shape[0], 1) + class_vector = len(x)*[c] + else: + class_vector = self.v_class.repeat(x.shape[0], 1) + out = self.model.forward(x, class_vector, self.truncation) # [N, 3, 128, 128], in [-1, 1] + return 0.5*(out+1) + + # Run model only until given layer + # Used to speed up PCA sample collection + def partial_forward(self, x, layer_name): + if layer_name in ['embeddings', 'generator.gen_z']: + n_layers = 0 + elif 'generator.layers' in layer_name: + layer_base = re.match('^generator\.layers\.[0-9]+', layer_name)[0] + n_layers = int(layer_base.split('.')[-1]) + 1 + else: + n_layers = len(self.model.config.layers) + + if not isinstance(x, list): + x = self.model.n_latents*[x] + + if isinstance(self.v_class, list): + labels = [c.repeat(x[0].shape[0], 1) for c in class_label] + embed = [self.model.embeddings(l) for l in labels] + else: + class_label = self.v_class.repeat(x[0].shape[0], 1) + embed = len(x)*[self.model.embeddings(class_label)] + + assert len(x) == self.model.n_latents, f'Expected {self.model.n_latents} latents, got {len(x)}' + assert len(embed) == self.model.n_latents, f'Expected {self.model.n_latents} class vectors, got {len(class_label)}' + + cond_vectors = [torch.cat((z, e), dim=1) for (z, e) in zip(x, embed)] + + # Generator forward + z = self.model.generator.gen_z(cond_vectors[0]) + z = z.view(-1, 4, 4, 16 * self.model.generator.config.channel_width) + z = z.permute(0, 3, 1, 2).contiguous() + + cond_idx = 1 + for i, layer in enumerate(self.model.generator.layers[:n_layers]): + if isinstance(layer, biggan.GenBlock): + z = layer(z, cond_vectors[cond_idx], self.truncation) + cond_idx += 1 + else: + z = layer(z) + + return None + +# Version 1: separate parameters +@singledispatch +def get_model(name, output_class, device, **kwargs): + # Check if optionally provided existing model can be reused + inst = kwargs.get('inst', None) + model = kwargs.get('model', None) + + if inst or model: + cached = model or inst.model + + network_same = (cached.model_name == name) + outclass_same = (cached.outclass == output_class) + can_change_class = ('BigGAN' in name) + + if network_same and (outclass_same or can_change_class): + cached.set_output_class(output_class) + return cached + + if name == 'DCGAN': + import warnings + warnings.filterwarnings("ignore", message="nn.functional.tanh is deprecated") + model = GANZooModel(device, 'DCGAN') + elif name == 'ProGAN': + model = ProGAN(device, output_class) + elif 'BigGAN' in name: + assert '-' in name, 'Please specify BigGAN resolution, e.g. BigGAN-512' + model = BigGAN(device, name.split('-')[-1], class_name=output_class) + elif name == 'StyleGAN': + model = StyleGAN(device, class_name=output_class) + elif name == 'StyleGAN2': + model = StyleGAN2(device, class_name=output_class) + else: + raise RuntimeError(f'Unknown model {name}') + + return model + +# Version 2: Config object +@get_model.register(Config) +def _(cfg, device, **kwargs): + kwargs['use_w'] = kwargs.get('use_w', cfg.use_w) # explicit arg can override cfg + return get_model(cfg.model, cfg.output_class, device, **kwargs) + +# Version 1: separate parameters +@singledispatch +def get_instrumented_model(name, output_class, layers, device, **kwargs): + model = get_model(name, output_class, device, **kwargs) + model.eval() + + inst = kwargs.get('inst', None) + if inst: + inst.close() + + if not isinstance(layers, list): + layers = [layers] + + # Verify given layer names + module_names = [name for (name, _) in model.named_modules()] + for layer_name in layers: + if not layer_name in module_names: + print(f"Layer '{layer_name}' not found in model!") + print("Available layers:", '\n'.join(module_names)) + raise RuntimeError(f"Unknown layer '{layer_name}''") + + # Reset StyleGANs to z mode for shape annotation + if hasattr(model, 'use_z'): + model.use_z() + + from netdissect.modelconfig import create_instrumented_model + inst = create_instrumented_model(SimpleNamespace( + model = model, + layers = layers, + cuda = device.type == 'cuda', + gen = True, + latent_shape = model.get_latent_shape() + )) + + if kwargs.get('use_w', False): + model.use_w() + + return inst + +# Version 2: Config object +@get_instrumented_model.register(Config) +def _(cfg, device, **kwargs): + kwargs['use_w'] = kwargs.get('use_w', cfg.use_w) # explicit arg can override cfg + return get_instrumented_model(cfg.model, cfg.output_class, cfg.layer, device, **kwargs) diff --git a/netdissect/LICENSE.txt b/netdissect/LICENSE.txt new file mode 100644 index 0000000000000000000000000000000000000000..f6b098bc5c232e162b20404c33d5335799a6cc59 --- /dev/null +++ b/netdissect/LICENSE.txt @@ -0,0 +1,19 @@ +Copyright (c) 2020 Erik Härkönen. + +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. \ No newline at end of file diff --git a/netdissect/__init__.py b/netdissect/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..39f0957560ff29b9ff0ee630e78972cd3ef187fb --- /dev/null +++ b/netdissect/__init__.py @@ -0,0 +1,60 @@ +''' +Netdissect package. + +To run dissection: + +1. Load up the convolutional model you wish to dissect, and wrap it + in an InstrumentedModel. Call imodel.retain_layers([layernames,..]) + to analyze a specified set of layers. +2. Load the segmentation dataset using the BrodenDataset class; + use the transform_image argument to normalize images to be + suitable for the model, or the size argument to truncate the dataset. +3. Write a function to recover the original image (with RGB scaled to + [0...1]) given a normalized dataset image; ReverseNormalize in this + package inverts transforms.Normalize for this purpose. +4. Choose a directory in which to write the output, and call + dissect(outdir, model, dataset). + +Example: + + from netdissect import InstrumentedModel, dissect + from netdissect import BrodenDataset, ReverseNormalize + + model = InstrumentedModel(load_my_model()) + model.eval() + model.cuda() + model.retain_layers(['conv1', 'conv2', 'conv3', 'conv4', 'conv5']) + bds = BrodenDataset('dataset/broden1_227', + transform_image=transforms.Compose([ + transforms.ToTensor(), + transforms.Normalize(IMAGE_MEAN, IMAGE_STDEV)]), + size=1000) + dissect('result/dissect', model, bds, + recover_image=ReverseNormalize(IMAGE_MEAN, IMAGE_STDEV), + examples_per_unit=10) +''' + +from .dissection import dissect, ReverseNormalize +from .dissection import ClassifierSegRunner, GeneratorSegRunner +from .dissection import ImageOnlySegRunner +from .broden import BrodenDataset, ScaleSegmentation, scatter_batch +from .segdata import MultiSegmentDataset +from .nethook import InstrumentedModel +from .zdataset import z_dataset_for_model, z_sample_for_model, standard_z_sample +from . import actviz +from . import progress +from . import runningstats +from . import sampler + +__all__ = [ + 'dissect', 'ReverseNormalize', + 'ClassifierSegRunner', 'GeneratorSegRunner', 'ImageOnlySegRunner', + 'BrodenDataset', 'ScaleSegmentation', 'scatter_batch', + 'MultiSegmentDataset', + 'InstrumentedModel', + 'z_dataset_for_model', 'z_sample_for_model', 'standard_z_sample' + 'actviz', + 'progress', + 'runningstats', + 'sampler' +] diff --git a/netdissect/__main__.py b/netdissect/__main__.py new file mode 100644 index 0000000000000000000000000000000000000000..e2bd9f630eaa0f45a6a201adcf356a1e092050cb --- /dev/null +++ b/netdissect/__main__.py @@ -0,0 +1,408 @@ +import torch, sys, os, argparse, textwrap, numbers, numpy, json, PIL +from torchvision import transforms +from torch.utils.data import TensorDataset +from netdissect.progress import verbose_progress, print_progress +from netdissect import InstrumentedModel, BrodenDataset, dissect +from netdissect import MultiSegmentDataset, GeneratorSegRunner +from netdissect import ImageOnlySegRunner +from netdissect.parallelfolder import ParallelImageFolders +from netdissect.zdataset import z_dataset_for_model +from netdissect.autoeval import autoimport_eval +from netdissect.modelconfig import create_instrumented_model +from netdissect.pidfile import exit_if_job_done, mark_job_done + +help_epilog = '''\ +Example: to dissect three layers of the pretrained alexnet in torchvision: + +python -m netdissect \\ + --model "torchvision.models.alexnet(pretrained=True)" \\ + --layers features.6:conv3 features.8:conv4 features.10:conv5 \\ + --imgsize 227 \\ + --outdir dissect/alexnet-imagenet + +To dissect a progressive GAN model: + +python -m netdissect \\ + --model "proggan.from_pth_file('model/churchoutdoor.pth')" \\ + --gan +''' + +def main(): + # Training settings + def strpair(arg): + p = tuple(arg.split(':')) + if len(p) == 1: + p = p + p + return p + def intpair(arg): + p = arg.split(',') + if len(p) == 1: + p = p + p + return tuple(int(v) for v in p) + + parser = argparse.ArgumentParser(description='Net dissect utility', + prog='python -m netdissect', + epilog=textwrap.dedent(help_epilog), + formatter_class=argparse.RawDescriptionHelpFormatter) + parser.add_argument('--model', type=str, default=None, + help='constructor for the model to test') + parser.add_argument('--pthfile', type=str, default=None, + help='filename of .pth file for the model') + parser.add_argument('--unstrict', action='store_true', default=False, + help='ignore unexpected pth parameters') + parser.add_argument('--submodule', type=str, default=None, + help='submodule to load from pthfile') + parser.add_argument('--outdir', type=str, default='dissect', + help='directory for dissection output') + parser.add_argument('--layers', type=strpair, nargs='+', + help='space-separated list of layer names to dissect' + + ', in the form layername[:reportedname]') + parser.add_argument('--segments', type=str, default='dataset/broden', + help='directory containing segmentation dataset') + parser.add_argument('--segmenter', type=str, default=None, + help='constructor for asegmenter class') + parser.add_argument('--download', action='store_true', default=False, + help='downloads Broden dataset if needed') + parser.add_argument('--imagedir', type=str, default=None, + help='directory containing image-only dataset') + parser.add_argument('--imgsize', type=intpair, default=(227, 227), + help='input image size to use') + parser.add_argument('--netname', type=str, default=None, + help='name for network in generated reports') + parser.add_argument('--meta', type=str, nargs='+', + help='json files of metadata to add to report') + parser.add_argument('--merge', type=str, + help='json file of unit data to merge in report') + parser.add_argument('--examples', type=int, default=20, + help='number of image examples per unit') + parser.add_argument('--size', type=int, default=10000, + help='dataset subset size to use') + parser.add_argument('--batch_size', type=int, default=100, + help='batch size for forward pass') + parser.add_argument('--num_workers', type=int, default=24, + help='number of DataLoader workers') + parser.add_argument('--quantile_threshold', type=strfloat, default=None, + choices=[FloatRange(0.0, 1.0), 'iqr'], + help='quantile to use for masks') + parser.add_argument('--no-labels', action='store_true', default=False, + help='disables labeling of units') + parser.add_argument('--maxiou', action='store_true', default=False, + help='enables maxiou calculation') + parser.add_argument('--covariance', action='store_true', default=False, + help='enables covariance calculation') + parser.add_argument('--rank_all_labels', action='store_true', default=False, + help='include low-information labels in rankings') + parser.add_argument('--no-images', action='store_true', default=False, + help='disables generation of unit images') + parser.add_argument('--no-report', action='store_true', default=False, + help='disables generation report summary') + parser.add_argument('--no-cuda', action='store_true', default=False, + help='disables CUDA usage') + parser.add_argument('--gen', action='store_true', default=False, + help='test a generator model (e.g., a GAN)') + parser.add_argument('--gan', action='store_true', default=False, + help='synonym for --gen') + parser.add_argument('--perturbation', default=None, + help='filename of perturbation attack to apply') + parser.add_argument('--add_scale_offset', action='store_true', default=None, + help='offsets masks according to stride and padding') + parser.add_argument('--quiet', action='store_true', default=False, + help='silences console output') + if len(sys.argv) == 1: + parser.print_usage(sys.stderr) + sys.exit(1) + args = parser.parse_args() + args.images = not args.no_images + args.report = not args.no_report + args.labels = not args.no_labels + if args.gan: + args.gen = args.gan + + # Set up console output + verbose_progress(not args.quiet) + + # Exit right away if job is already done or being done. + if args.outdir is not None: + exit_if_job_done(args.outdir) + + # Speed up pytorch + torch.backends.cudnn.benchmark = True + + # Special case: download flag without model to test. + if args.model is None and args.download: + from netdissect.broden import ensure_broden_downloaded + for resolution in [224, 227, 384]: + ensure_broden_downloaded(args.segments, resolution, 1) + from netdissect.segmenter import ensure_upp_segmenter_downloaded + ensure_upp_segmenter_downloaded('dataset/segmodel') + sys.exit(0) + + # Help if broden is not present + if not args.gen and not args.imagedir and not os.path.isdir(args.segments): + print_progress('Segmentation dataset not found at %s.' % args.segments) + print_progress('Specify dataset directory using --segments [DIR]') + print_progress('To download Broden, run: netdissect --download') + sys.exit(1) + + # Default segmenter class + if args.gen and args.segmenter is None: + args.segmenter = ("netdissect.segmenter.UnifiedParsingSegmenter(" + + "segsizes=[256], segdiv='quad')") + + # Default threshold + if args.quantile_threshold is None: + if args.gen: + args.quantile_threshold = 'iqr' + else: + args.quantile_threshold = 0.005 + + # Set up CUDA + args.cuda = not args.no_cuda and torch.cuda.is_available() + if args.cuda: + torch.backends.cudnn.benchmark = True + + # Construct the network with specified layers instrumented + if args.model is None: + print_progress('No model specified') + sys.exit(1) + model = create_instrumented_model(args) + + # Update any metadata from files, if any + meta = getattr(model, 'meta', {}) + if args.meta: + for mfilename in args.meta: + with open(mfilename) as f: + meta.update(json.load(f)) + + # Load any merge data from files + mergedata = None + if args.merge: + with open(args.merge) as f: + mergedata = json.load(f) + + # Set up the output directory, verify write access + if args.outdir is None: + args.outdir = os.path.join('dissect', type(model).__name__) + exit_if_job_done(args.outdir) + print_progress('Writing output into %s.' % args.outdir) + os.makedirs(args.outdir, exist_ok=True) + train_dataset = None + + if not args.gen: + # Load dataset for classifier case. + # Load perturbation + perturbation = numpy.load(args.perturbation + ) if args.perturbation else None + segrunner = None + + # Load broden dataset + if args.imagedir is not None: + dataset = try_to_load_images(args.imagedir, args.imgsize, + perturbation, args.size) + segrunner = ImageOnlySegRunner(dataset) + else: + dataset = try_to_load_broden(args.segments, args.imgsize, 1, + perturbation, args.download, args.size) + if dataset is None: + dataset = try_to_load_multiseg(args.segments, args.imgsize, + perturbation, args.size) + if dataset is None: + print_progress('No segmentation dataset found in %s', + args.segments) + print_progress('use --download to download Broden.') + sys.exit(1) + else: + # For segmenter case the dataset is just a random z + dataset = z_dataset_for_model(model, args.size) + train_dataset = z_dataset_for_model(model, args.size, seed=2) + segrunner = GeneratorSegRunner(autoimport_eval(args.segmenter)) + + # Run dissect + dissect(args.outdir, model, dataset, + train_dataset=train_dataset, + segrunner=segrunner, + examples_per_unit=args.examples, + netname=args.netname, + quantile_threshold=args.quantile_threshold, + meta=meta, + merge=mergedata, + make_images=args.images, + make_labels=args.labels, + make_maxiou=args.maxiou, + make_covariance=args.covariance, + make_report=args.report, + make_row_images=args.images, + make_single_images=True, + rank_all_labels=args.rank_all_labels, + batch_size=args.batch_size, + num_workers=args.num_workers, + settings=vars(args)) + + # Mark the directory so that it's not done again. + mark_job_done(args.outdir) + +class AddPerturbation(object): + def __init__(self, perturbation): + self.perturbation = perturbation + + def __call__(self, pic): + if self.perturbation is None: + return pic + # Convert to a numpy float32 array + npyimg = numpy.array(pic, numpy.uint8, copy=False + ).astype(numpy.float32) + # Center the perturbation + oy, ox = ((self.perturbation.shape[d] - npyimg.shape[d]) // 2 + for d in [0, 1]) + npyimg += self.perturbation[ + oy:oy+npyimg.shape[0], ox:ox+npyimg.shape[1]] + # Pytorch conventions: as a float it should be [0..1] + npyimg.clip(0, 255, npyimg) + return npyimg / 255.0 + +def test_dissection(): + verbose_progress(True) + from torchvision.models import alexnet + from torchvision import transforms + model = InstrumentedModel(alexnet(pretrained=True)) + model.eval() + # Load an alexnet + model.retain_layers([ + ('features.0', 'conv1'), + ('features.3', 'conv2'), + ('features.6', 'conv3'), + ('features.8', 'conv4'), + ('features.10', 'conv5') ]) + # load broden dataset + bds = BrodenDataset('dataset/broden', + transform=transforms.Compose([ + transforms.ToTensor(), + transforms.Normalize(IMAGE_MEAN, IMAGE_STDEV)]), + size=100) + # run dissect + dissect('dissect/test', model, bds, + examples_per_unit=10) + +def try_to_load_images(directory, imgsize, perturbation, size): + # Load plain image dataset + # TODO: allow other normalizations. + return ParallelImageFolders( + [directory], + transform=transforms.Compose([ + transforms.Resize(imgsize), + AddPerturbation(perturbation), + transforms.ToTensor(), + transforms.Normalize(IMAGE_MEAN, IMAGE_STDEV)]), + size=size) + +def try_to_load_broden(directory, imgsize, broden_version, perturbation, + download, size): + # Load broden dataset + ds_resolution = (224 if max(imgsize) <= 224 else + 227 if max(imgsize) <= 227 else 384) + if not os.path.isfile(os.path.join(directory, + 'broden%d_%d' % (broden_version, ds_resolution), 'index.csv')): + return None + return BrodenDataset(directory, + resolution=ds_resolution, + download=download, + broden_version=broden_version, + transform=transforms.Compose([ + transforms.Resize(imgsize), + AddPerturbation(perturbation), + transforms.ToTensor(), + transforms.Normalize(IMAGE_MEAN, IMAGE_STDEV)]), + size=size) + +def try_to_load_multiseg(directory, imgsize, perturbation, size): + if not os.path.isfile(os.path.join(directory, 'labelnames.json')): + return None + minsize = min(imgsize) if hasattr(imgsize, '__iter__') else imgsize + return MultiSegmentDataset(directory, + transform=(transforms.Compose([ + transforms.Resize(minsize), + transforms.CenterCrop(imgsize), + AddPerturbation(perturbation), + transforms.ToTensor(), + transforms.Normalize(IMAGE_MEAN, IMAGE_STDEV)]), + transforms.Compose([ + transforms.Resize(minsize, interpolation=PIL.Image.NEAREST), + transforms.CenterCrop(imgsize)])), + size=size) + +def add_scale_offset_info(model, layer_names): + ''' + Creates a 'scale_offset' property on the model which guesses + how to offset the featuremap, in cases where the convolutional + padding does not exacly correspond to keeping featuremap pixels + centered on the downsampled regions of the input. This mainly + shows up in AlexNet: ResNet and VGG pad convolutions to keep + them centered and do not need this. + ''' + model.scale_offset = {} + seen = set() + sequence = [] + aka_map = {} + for name in layer_names: + aka = name + if not isinstance(aka, str): + name, aka = name + aka_map[name] = aka + for name, layer in model.named_modules(): + sequence.append(layer) + if name in aka_map: + seen.add(name) + aka = aka_map[name] + model.scale_offset[aka] = sequence_scale_offset(sequence) + for name in aka_map: + assert name in seen, ('Layer %s not found' % name) + +def dilation_scale_offset(dilations): + '''Composes a list of (k, s, p) into a single total scale and offset.''' + if len(dilations) == 0: + return (1, 0) + scale, offset = dilation_scale_offset(dilations[1:]) + kernel, stride, padding = dilations[0] + scale *= stride + offset *= stride + offset += (kernel - 1) / 2.0 - padding + return scale, offset + +def dilations(modulelist): + '''Converts a list of modules to (kernel_size, stride, padding)''' + result = [] + for module in modulelist: + settings = tuple(getattr(module, n, d) + for n, d in (('kernel_size', 1), ('stride', 1), ('padding', 0))) + settings = (((s, s) if not isinstance(s, tuple) else s) + for s in settings) + if settings != ((1, 1), (1, 1), (0, 0)): + result.append(zip(*settings)) + return zip(*result) + +def sequence_scale_offset(modulelist): + '''Returns (yscale, yoffset), (xscale, xoffset) given a list of modules''' + return tuple(dilation_scale_offset(d) for d in dilations(modulelist)) + + +def strfloat(s): + try: + return float(s) + except: + return s + +class FloatRange(object): + def __init__(self, start, end): + self.start = start + self.end = end + def __eq__(self, other): + return isinstance(other, float) and self.start <= other <= self.end + def __repr__(self): + return '[%g-%g]' % (self.start, self.end) + +# Many models use this normalization. +IMAGE_MEAN = [0.485, 0.456, 0.406] +IMAGE_STDEV = [0.229, 0.224, 0.225] + +if __name__ == '__main__': + main() diff --git a/netdissect/__pycache__/__init__.cpython-310.pyc b/netdissect/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f8e10b9f6ff7841c034eb0514673828ccce84147 Binary files /dev/null and b/netdissect/__pycache__/__init__.cpython-310.pyc differ diff --git a/netdissect/__pycache__/actviz.cpython-310.pyc b/netdissect/__pycache__/actviz.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..00358e495e7de4c11e33dd8e3c2a5ddf5d6bcff0 Binary files /dev/null and b/netdissect/__pycache__/actviz.cpython-310.pyc differ diff --git a/netdissect/__pycache__/autoeval.cpython-310.pyc b/netdissect/__pycache__/autoeval.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7e92254fb7db77c25b6f6a0653fe326acb64d3c6 Binary files /dev/null and b/netdissect/__pycache__/autoeval.cpython-310.pyc differ diff --git a/netdissect/__pycache__/broden.cpython-310.pyc b/netdissect/__pycache__/broden.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1651ea611348c7a8ed86d62f0ad532bc17605a41 Binary files /dev/null and b/netdissect/__pycache__/broden.cpython-310.pyc differ diff --git a/netdissect/__pycache__/dissection.cpython-310.pyc b/netdissect/__pycache__/dissection.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7b58ed509ee3d3df4702c55ca538a6b961555733 Binary files /dev/null and b/netdissect/__pycache__/dissection.cpython-310.pyc differ diff --git a/netdissect/__pycache__/easydict.cpython-310.pyc b/netdissect/__pycache__/easydict.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7274ec0de9dd19af8c7f0ebda81386ed2c7e85ed Binary files /dev/null and b/netdissect/__pycache__/easydict.cpython-310.pyc differ diff --git a/netdissect/__pycache__/modelconfig.cpython-310.pyc b/netdissect/__pycache__/modelconfig.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..682a0922e10f43dd437811cf35c7c5e26cba6e6d Binary files /dev/null and b/netdissect/__pycache__/modelconfig.cpython-310.pyc differ diff --git a/netdissect/__pycache__/nethook.cpython-310.pyc b/netdissect/__pycache__/nethook.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8e6d3bc444f0d7be470d983ff5c3561c33ba91bf Binary files /dev/null and b/netdissect/__pycache__/nethook.cpython-310.pyc differ diff --git a/netdissect/__pycache__/parallelfolder.cpython-310.pyc b/netdissect/__pycache__/parallelfolder.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..15a97b2252095f64f9aebc36d1dd33c26170ab6d Binary files /dev/null and b/netdissect/__pycache__/parallelfolder.cpython-310.pyc differ diff --git a/netdissect/__pycache__/proggan.cpython-310.pyc b/netdissect/__pycache__/proggan.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ac3142cab2f65c483c7703f759f2976e7775805f Binary files /dev/null and b/netdissect/__pycache__/proggan.cpython-310.pyc differ diff --git a/netdissect/__pycache__/progress.cpython-310.pyc b/netdissect/__pycache__/progress.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7b28109ba1b038d2f91f1bf84840ce64d77f6cab Binary files /dev/null and b/netdissect/__pycache__/progress.cpython-310.pyc differ diff --git a/netdissect/__pycache__/runningstats.cpython-310.pyc b/netdissect/__pycache__/runningstats.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..72cd88e93c94437f92de1cbccfbaa265e13e3a37 Binary files /dev/null and b/netdissect/__pycache__/runningstats.cpython-310.pyc differ diff --git a/netdissect/__pycache__/sampler.cpython-310.pyc b/netdissect/__pycache__/sampler.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d651888a0b2e5a72114acbd2ab90acbc09de3c2e Binary files /dev/null and b/netdissect/__pycache__/sampler.cpython-310.pyc differ diff --git a/netdissect/__pycache__/segdata.cpython-310.pyc b/netdissect/__pycache__/segdata.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..96d8596d2797f8fe8795a58ff11681e3d942590e Binary files /dev/null and b/netdissect/__pycache__/segdata.cpython-310.pyc differ diff --git a/netdissect/__pycache__/segmenter.cpython-310.pyc b/netdissect/__pycache__/segmenter.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bebbab82088e880d12f87ee60b8560fe66ad15a6 Binary files /dev/null and b/netdissect/__pycache__/segmenter.cpython-310.pyc differ diff --git a/netdissect/__pycache__/segviz.cpython-310.pyc b/netdissect/__pycache__/segviz.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8ae7d90ef4abc83ccae400aeadd2bb6183652cc8 Binary files /dev/null and b/netdissect/__pycache__/segviz.cpython-310.pyc differ diff --git a/netdissect/__pycache__/workerpool.cpython-310.pyc b/netdissect/__pycache__/workerpool.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..eaaed188cb60230ea808eaa61e5b25181937d7e2 Binary files /dev/null and b/netdissect/__pycache__/workerpool.cpython-310.pyc differ diff --git a/netdissect/__pycache__/zdataset.cpython-310.pyc b/netdissect/__pycache__/zdataset.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e9a5db9dae94810a57478216ae6576ee81f389f2 Binary files /dev/null and b/netdissect/__pycache__/zdataset.cpython-310.pyc differ diff --git a/netdissect/aceoptimize.py b/netdissect/aceoptimize.py new file mode 100644 index 0000000000000000000000000000000000000000..46ac0620073a0c26e9ead14b20db57c586ce15aa --- /dev/null +++ b/netdissect/aceoptimize.py @@ -0,0 +1,934 @@ +# Instantiate the segmenter gadget. +# Instantiate the GAN to optimize over +# Instrument the GAN for editing and optimization. +# Read quantile stats to learn 99.9th percentile for each unit, +# and also the 0.01th percentile. +# Read the median activation conditioned on door presence. + +import os, sys, numpy, torch, argparse, skimage, json, shutil +from PIL import Image +from torch.utils.data import TensorDataset +from matplotlib.figure import Figure +from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas +import matplotlib.gridspec as gridspec +from scipy.ndimage.morphology import binary_dilation + +import netdissect.zdataset +import netdissect.nethook +from netdissect.dissection import safe_dir_name +from netdissect.progress import verbose_progress, default_progress +from netdissect.progress import print_progress, desc_progress, post_progress +from netdissect.easydict import EasyDict +from netdissect.workerpool import WorkerPool, WorkerBase +from netdissect.runningstats import RunningQuantile +from netdissect.pidfile import pidfile_taken +from netdissect.modelconfig import create_instrumented_model +from netdissect.autoeval import autoimport_eval + +def main(): + parser = argparse.ArgumentParser(description='ACE optimization utility', + prog='python -m netdissect.aceoptimize') + parser.add_argument('--model', type=str, default=None, + help='constructor for the model to test') + parser.add_argument('--pthfile', type=str, default=None, + help='filename of .pth file for the model') + parser.add_argument('--segmenter', type=str, default=None, + help='constructor for asegmenter class') + parser.add_argument('--classname', type=str, default=None, + help='intervention classname') + parser.add_argument('--layer', type=str, default='layer4', + help='layer name') + parser.add_argument('--search_size', type=int, default=10000, + help='size of search for finding training locations') + parser.add_argument('--train_size', type=int, default=1000, + help='size of training set') + parser.add_argument('--eval_size', type=int, default=200, + help='size of eval set') + parser.add_argument('--inference_batch_size', type=int, default=10, + help='forward pass batch size') + parser.add_argument('--train_batch_size', type=int, default=2, + help='backprop pass batch size') + parser.add_argument('--train_update_freq', type=int, default=10, + help='number of batches for each training update') + parser.add_argument('--train_epochs', type=int, default=10, + help='number of epochs of training') + parser.add_argument('--l2_lambda', type=float, default=0.005, + help='l2 regularizer hyperparameter') + parser.add_argument('--eval_only', action='store_true', default=False, + help='reruns eval only on trained snapshots') + parser.add_argument('--no-cuda', action='store_true', default=False, + help='disables CUDA usage') + parser.add_argument('--no-cache', action='store_true', default=False, + help='disables reading of cache') + parser.add_argument('--outdir', type=str, default=None, + help='dissection directory') + parser.add_argument('--variant', type=str, default=None, + help='experiment variant') + args = parser.parse_args() + args.cuda = not args.no_cuda and torch.cuda.is_available() + torch.backends.cudnn.benchmark = True + + run_command(args) + +def run_command(args): + verbose_progress(True) + progress = default_progress() + classname = args.classname # 'door' + layer = args.layer # 'layer4' + num_eval_units = 20 + + assert os.path.isfile(os.path.join(args.outdir, 'dissect.json')), ( + "Should be a dissection directory") + + if args.variant is None: + args.variant = 'ace' + + if args.l2_lambda != 0.005: + args.variant = '%s_reg%g' % (args.variant, args.l2_lambda) + + cachedir = os.path.join(args.outdir, safe_dir_name(layer), args.variant, + classname) + + if pidfile_taken(os.path.join(cachedir, 'lock.pid'), True): + sys.exit(0) + + # Take defaults for model constructor etc from dissect.json settings. + with open(os.path.join(args.outdir, 'dissect.json')) as f: + dissection = EasyDict(json.load(f)) + if args.model is None: + args.model = dissection.settings.model + if args.pthfile is None: + args.pthfile = dissection.settings.pthfile + if args.segmenter is None: + args.segmenter = dissection.settings.segmenter + # Default segmenter class + if args.segmenter is None: + args.segmenter = ("netdissect.segmenter.UnifiedParsingSegmenter(" + + "segsizes=[256], segdiv='quad')") + + if (not args.no_cache and + os.path.isfile(os.path.join(cachedir, 'snapshots', 'epoch-%d.npy' % ( + args.train_epochs - 1))) and + os.path.isfile(os.path.join(cachedir, 'report.json'))): + print('%s already done' % cachedir) + sys.exit(0) + + os.makedirs(cachedir, exist_ok=True) + + # Instantiate generator + model = create_instrumented_model(args, gen=True, edit=True, + layers=[args.layer]) + if model is None: + print('No model specified') + sys.exit(1) + # Instantiate segmenter + segmenter = autoimport_eval(args.segmenter) + labelnames, catname = segmenter.get_label_and_category_names() + classnum = [i for i, (n, c) in enumerate(labelnames) if n == classname][0] + num_classes = len(labelnames) + with open(os.path.join(cachedir, 'labelnames.json'), 'w') as f: + json.dump(labelnames, f, indent=1) + + # Sample sets for training. + full_sample = netdissect.zdataset.z_sample_for_model(model, + args.search_size, seed=10) + second_sample = netdissect.zdataset.z_sample_for_model(model, + args.search_size, seed=11) + # Load any cached data. + cache_filename = os.path.join(cachedir, 'corpus.npz') + corpus = EasyDict() + try: + if not args.no_cache: + corpus = EasyDict({k: torch.from_numpy(v) + for k, v in numpy.load(cache_filename).items()}) + except: + pass + + # The steps for the computation. + compute_present_locations(args, corpus, cache_filename, + model, segmenter, classnum, full_sample) + compute_mean_present_features(args, corpus, cache_filename, model) + compute_feature_quantiles(args, corpus, cache_filename, model, full_sample) + compute_candidate_locations(args, corpus, cache_filename, model, segmenter, + classnum, second_sample) + # visualize_training_locations(args, corpus, cachedir, model) + init_ablation = initial_ablation(args, args.outdir) + scores = train_ablation(args, corpus, cache_filename, + model, segmenter, classnum, init_ablation) + summarize_scores(args, corpus, cachedir, layer, classname, + args.variant, scores) + if args.variant == 'ace': + add_ace_ranking_to_dissection(args.outdir, layer, classname, scores) + # TODO: do some evaluation. + +class SaveImageWorker(WorkerBase): + def work(self, data, filename): + Image.fromarray(data).save(filename, optimize=True, quality=80) + +def plot_heatmap(output_filename, data, size=256): + fig = Figure(figsize=(1, 1), dpi=size) + canvas = FigureCanvas(fig) + gs = gridspec.GridSpec(1, 1, left=0.0, right=1.0, bottom=0.0, top=1.0) + ax = fig.add_subplot(gs[0]) + ax.set_axis_off() + ax.imshow(data, cmap='hot', aspect='equal', interpolation='nearest', + vmin=-1, vmax=1) + canvas.print_figure(output_filename, format='png') + + +def draw_heatmap(output_filename, data, size=256): + fig = Figure(figsize=(1, 1), dpi=size) + canvas = FigureCanvas(fig) + gs = gridspec.GridSpec(1, 1, left=0.0, right=1.0, bottom=0.0, top=1.0) + ax = fig.add_subplot(gs[0]) + ax.set_axis_off() + ax.imshow(data, cmap='hot', aspect='equal', interpolation='nearest', + vmin=-1, vmax=1) + canvas.draw() # draw the canvas, cache the renderer + image = numpy.fromstring(canvas.tostring_rgb(), dtype='uint8').reshape( + (size, size, 3)) + return image + +def compute_present_locations(args, corpus, cache_filename, + model, segmenter, classnum, full_sample): + # Phase 1. Identify a set of locations where there are doorways. + # Segment the image and find featuremap pixels that maximize the number + # of doorway pixels under the featuremap pixel. + if all(k in corpus for k in ['present_indices', + 'object_present_sample', 'object_present_location', + 'object_location_popularity', 'weighted_mean_present_feature']): + return + progress = default_progress() + feature_shape = model.feature_shape[args.layer][2:] + num_locations = numpy.prod(feature_shape).item() + num_units = model.feature_shape[args.layer][1] + with torch.no_grad(): + weighted_feature_sum = torch.zeros(num_units).cuda() + object_presence_scores = [] + for [zbatch] in progress( + torch.utils.data.DataLoader(TensorDataset(full_sample), + batch_size=args.inference_batch_size, num_workers=10, + pin_memory=True), + desc="Object pool"): + zbatch = zbatch.cuda() + tensor_image = model(zbatch) + segmented_image = segmenter.segment_batch(tensor_image, + downsample=2) + mask = (segmented_image == classnum).max(1)[0] + score = torch.nn.functional.adaptive_avg_pool2d( + mask.float(), feature_shape) + object_presence_scores.append(score.cpu()) + feat = model.retained_layer(args.layer) + weighted_feature_sum += (feat * score[:,None,:,:]).view( + feat.shape[0],feat.shape[1], -1).sum(2).sum(0) + object_presence_at_feature = torch.cat(object_presence_scores) + object_presence_at_image, object_location_in_image = ( + object_presence_at_feature.view(args.search_size, -1).max(1)) + best_presence_scores, best_presence_images = torch.sort( + -object_presence_at_image) + all_present_indices = torch.sort( + best_presence_images[:(args.train_size+args.eval_size)])[0] + corpus.present_indices = all_present_indices[:args.train_size] + corpus.object_present_sample = full_sample[corpus.present_indices] + corpus.object_present_location = object_location_in_image[ + corpus.present_indices] + corpus.object_location_popularity = torch.bincount( + corpus.object_present_location, + minlength=num_locations) + corpus.weighted_mean_present_feature = (weighted_feature_sum.cpu() / ( + 1e-20 + object_presence_at_feature.view(-1).sum())) + corpus.eval_present_indices = all_present_indices[-args.eval_size:] + corpus.eval_present_sample = full_sample[corpus.eval_present_indices] + corpus.eval_present_location = object_location_in_image[ + corpus.eval_present_indices] + + if cache_filename: + numpy.savez(cache_filename, **corpus) + +def compute_mean_present_features(args, corpus, cache_filename, model): + # Phase 1.5. Figure mean activations for every channel where there + # is a doorway. + if all(k in corpus for k in ['mean_present_feature']): + return + progress = default_progress() + with torch.no_grad(): + total_present_feature = 0 + for [zbatch, featloc] in progress( + torch.utils.data.DataLoader(TensorDataset( + corpus.object_present_sample, + corpus.object_present_location), + batch_size=args.inference_batch_size, num_workers=10, + pin_memory=True), + desc="Mean activations"): + zbatch = zbatch.cuda() + featloc = featloc.cuda() + tensor_image = model(zbatch) + feat = model.retained_layer(args.layer) + flatfeat = feat.view(feat.shape[0], feat.shape[1], -1) + sum_feature_at_obj = flatfeat[ + torch.arange(feat.shape[0]).to(feat.device), :, featloc + ].sum(0) + total_present_feature = total_present_feature + sum_feature_at_obj + corpus.mean_present_feature = (total_present_feature / len( + corpus.object_present_sample)).cpu() + if cache_filename: + numpy.savez(cache_filename, **corpus) + +def compute_feature_quantiles(args, corpus, cache_filename, model, full_sample): + # Phase 1.6. Figure the 99% and 99.9%ile of every feature. + if all(k in corpus for k in ['feature_99', 'feature_999']): + return + progress = default_progress() + with torch.no_grad(): + rq = RunningQuantile(resolution=10000) # 10x what's needed. + for [zbatch] in progress( + torch.utils.data.DataLoader(TensorDataset(full_sample), + batch_size=args.inference_batch_size, num_workers=10, + pin_memory=True), + desc="Calculating 0.999 quantile"): + zbatch = zbatch.cuda() + tensor_image = model(zbatch) + feat = model.retained_layer(args.layer) + rq.add(feat.permute(0, 2, 3, 1 + ).contiguous().view(-1, feat.shape[1])) + result = rq.quantiles([0.001, 0.01, 0.1, 0.5, 0.9, 0.99, 0.999]) + corpus.feature_001 = result[:, 0].cpu() + corpus.feature_01 = result[:, 1].cpu() + corpus.feature_10 = result[:, 2].cpu() + corpus.feature_50 = result[:, 3].cpu() + corpus.feature_90 = result[:, 4].cpu() + corpus.feature_99 = result[:, 5].cpu() + corpus.feature_999 = result[:, 6].cpu() + numpy.savez(cache_filename, **corpus) + +def compute_candidate_locations(args, corpus, cache_filename, model, + segmenter, classnum, second_sample): + # Phase 2. Identify a set of candidate locations for doorways. + # Place the median doorway activation in every location of an image + # and identify where it can go that doorway pixels increase. + if all(k in corpus for k in ['candidate_indices', + 'candidate_sample', 'candidate_score', + 'candidate_location', 'object_score_at_candidate', + 'candidate_location_popularity']): + return + progress = default_progress() + feature_shape = model.feature_shape[args.layer][2:] + num_locations = numpy.prod(feature_shape).item() + with torch.no_grad(): + # Simplify - just treat all locations as possible + possible_locations = numpy.arange(num_locations) + + # Speed up search for locations, by weighting probed locations + # according to observed distribution. + location_weights = (corpus.object_location_popularity).double() + location_weights += (location_weights.mean()) / 10.0 + location_weights = location_weights / location_weights.sum() + + candidate_scores = [] + object_scores = [] + prng = numpy.random.RandomState(1) + for [zbatch] in progress( + torch.utils.data.DataLoader(TensorDataset(second_sample), + batch_size=args.inference_batch_size, num_workers=10, + pin_memory=True), + desc="Candidate pool"): + batch_scores = torch.zeros((len(zbatch),) + feature_shape).cuda() + flat_batch_scores = batch_scores.view(len(zbatch), -1) + zbatch = zbatch.cuda() + tensor_image = model(zbatch) + segmented_image = segmenter.segment_batch(tensor_image, + downsample=2) + mask = (segmented_image == classnum).max(1)[0] + object_score = torch.nn.functional.adaptive_avg_pool2d( + mask.float(), feature_shape) + baseline_presence = mask.float().view(mask.shape[0], -1).sum(1) + + edit_mask = torch.zeros((1, 1) + feature_shape).cuda() + if '_tcm' in args.variant: + # variant: top-conditional-mean + replace_vec = (corpus.mean_present_feature + [None,:,None,None].cuda()) + else: # default: weighted mean + replace_vec = (corpus.weighted_mean_present_feature + [None,:,None,None].cuda()) + # Sample 10 random locations to examine. + for loc in prng.choice(possible_locations, replace=False, + p=location_weights, size=5): + edit_mask.zero_() + edit_mask.view(-1)[loc] = 1 + model.edit_layer(args.layer, + ablation=edit_mask, replacement=replace_vec) + tensor_image = model(zbatch) + segmented_image = segmenter.segment_batch(tensor_image, + downsample=2) + mask = (segmented_image == classnum).max(1)[0] + modified_presence = mask.float().view( + mask.shape[0], -1).sum(1) + flat_batch_scores[:,loc] = ( + modified_presence - baseline_presence) + candidate_scores.append(batch_scores.cpu()) + object_scores.append(object_score.cpu()) + + object_scores = torch.cat(object_scores) + candidate_scores = torch.cat(candidate_scores) + # Eliminate candidates where the object is present. + candidate_scores = candidate_scores * (object_scores == 0).float() + candidate_score_at_image, candidate_location_in_image = ( + candidate_scores.view(args.search_size, -1).max(1)) + best_candidate_scores, best_candidate_images = torch.sort( + -candidate_score_at_image) + all_candidate_indices = torch.sort( + best_candidate_images[:(args.train_size+args.eval_size)])[0] + corpus.candidate_indices = all_candidate_indices[:args.train_size] + corpus.candidate_sample = second_sample[corpus.candidate_indices] + corpus.candidate_location = candidate_location_in_image[ + corpus.candidate_indices] + corpus.candidate_score = candidate_score_at_image[ + corpus.candidate_indices] + corpus.object_score_at_candidate = object_scores.view( + len(object_scores), -1)[ + corpus.candidate_indices, corpus.candidate_location] + corpus.candidate_location_popularity = torch.bincount( + corpus.candidate_location, + minlength=num_locations) + corpus.eval_candidate_indices = all_candidate_indices[ + -args.eval_size:] + corpus.eval_candidate_sample = second_sample[ + corpus.eval_candidate_indices] + corpus.eval_candidate_location = candidate_location_in_image[ + corpus.eval_candidate_indices] + numpy.savez(cache_filename, **corpus) + +def visualize_training_locations(args, corpus, cachedir, model): + # Phase 2.5 Create visualizations of the corpus images. + progress = default_progress() + feature_shape = model.feature_shape[args.layer][2:] + num_locations = numpy.prod(feature_shape).item() + with torch.no_grad(): + imagedir = os.path.join(cachedir, 'image') + os.makedirs(imagedir, exist_ok=True) + image_saver = WorkerPool(SaveImageWorker) + for group, group_sample, group_location, group_indices in [ + ('present', + corpus.object_present_sample, + corpus.object_present_location, + corpus.present_indices), + ('candidate', + corpus.candidate_sample, + corpus.candidate_location, + corpus.candidate_indices)]: + for [zbatch, featloc, indices] in progress( + torch.utils.data.DataLoader(TensorDataset( + group_sample, group_location, group_indices), + batch_size=args.inference_batch_size, num_workers=10, + pin_memory=True), + desc="Visualize %s" % group): + zbatch = zbatch.cuda() + tensor_image = model(zbatch) + feature_mask = torch.zeros((len(zbatch), 1) + feature_shape) + feature_mask.view(len(zbatch), -1).scatter_( + 1, featloc[:,None], 1) + feature_mask = torch.nn.functional.adaptive_max_pool2d( + feature_mask.float(), tensor_image.shape[-2:]).cuda() + yellow = torch.Tensor([1.0, 1.0, -1.0] + )[None, :, None, None].cuda() + tensor_image = tensor_image * (1 - 0.5 * feature_mask) + ( + 0.5 * feature_mask * yellow) + byte_image = (((tensor_image+1)/2)*255).clamp(0, 255).byte() + numpy_image = byte_image.permute(0, 2, 3, 1).cpu().numpy() + for i, index in enumerate(indices): + image_saver.add(numpy_image[i], os.path.join(imagedir, + '%s_%d.jpg' % (group, index))) + image_saver.join() + +def scale_summary(scale, lownums, highnums): + value, order = (-(scale.detach())).cpu().sort(0) + lowsum = ' '.join('%d: %.3g' % (o.item(), -v.item()) + for v, o in zip(value[:lownums], order[:lownums])) + highsum = ' '.join('%d: %.3g' % (o.item(), -v.item()) + for v, o in zip(value[-highnums:], order[-highnums:])) + return lowsum + ' ... ' + highsum + +# Phase 3. Given those two sets, now optimize a such that: +# Door pred lost if we take 0 * a at a candidate (1) +# Door pred gained If we take 99.9th activation * a at a candiate (1) +# + +# ADE_au = E | on - E | off) +# = cand-frac E_cand | on + nocand-frac E_cand | on +# - door-frac E_door | off + nodoor-frac E_nodoor | off +# approx = cand-frac E_cand | on - door-frac E_door | off + K +# Each batch has both types, and minimizes +# door-frac sum(s_c) when pixel off - cand-frac sum(s_c) when pixel on + +def initial_ablation(args, dissectdir): + # Load initialization from dissection, based on iou scores. + with open(os.path.join(dissectdir, 'dissect.json')) as f: + dissection = EasyDict(json.load(f)) + lrec = [l for l in dissection.layers if l.layer == args.layer][0] + rrec = [r for r in lrec.rankings if r.name == '%s-iou' % args.classname + ][0] + init_scores = -torch.tensor(rrec.score) + return init_scores / init_scores.max() + +def ace_loss(segmenter, classnum, model, layer, high_replacement, ablation, + pbatch, ploc, cbatch, cloc, run_backward=False, + discrete_pixels=False, + discrete_units=False, + mixed_units=False, + ablation_only=False, + fullimage_measurement=False, + fullimage_ablation=False, + ): + feature_shape = model.feature_shape[layer][2:] + if discrete_units: # discretize ablation to the top N units + assert discrete_units > 0 + d = torch.zeros_like(ablation) + top_units = torch.topk(ablation.view(-1), discrete_units)[1] + if mixed_units: + d.view(-1)[top_units] = ablation.view(-1)[top_units] + else: + d.view(-1)[top_units] = 1 + ablation = d + # First, ablate a sample of locations with positive presence + # and see how much the presence is reduced. + p_mask = torch.zeros((len(pbatch), 1) + feature_shape) + if fullimage_ablation: + p_mask[...] = 1 + else: + p_mask.view(len(pbatch), -1).scatter_(1, ploc[:,None], 1) + p_mask = p_mask.cuda() + a_p_mask = (ablation * p_mask) + model.edit_layer(layer, ablation=a_p_mask, replacement=None) + tensor_images = model(pbatch.cuda()) + assert model._ablation[layer] is a_p_mask + erase_effect, erased_mask = segmenter.predict_single_class( + tensor_images, classnum, downsample=2) + if discrete_pixels: # pixel loss: use mask instead of pred + erase_effect = erased_mask.float() + erase_downsampled = torch.nn.functional.adaptive_avg_pool2d( + erase_effect[:,None,:,:], feature_shape)[:,0,:,:] + if fullimage_measurement: + erase_loss = erase_downsampled.sum() + else: + erase_at_loc = erase_downsampled.view(len(erase_downsampled), -1 + )[torch.arange(len(erase_downsampled)), ploc] + erase_loss = erase_at_loc.sum() + if run_backward: + erase_loss.backward() + if ablation_only: + return erase_loss + # Second, activate a sample of locations that are candidates for + # insertion and see how much the presence is increased. + c_mask = torch.zeros((len(cbatch), 1) + feature_shape) + c_mask.view(len(cbatch), -1).scatter_(1, cloc[:,None], 1) + c_mask = c_mask.cuda() + a_c_mask = (ablation * c_mask) + model.edit_layer(layer, ablation=a_c_mask, replacement=high_replacement) + tensor_images = model(cbatch.cuda()) + assert model._ablation[layer] is a_c_mask + add_effect, added_mask = segmenter.predict_single_class( + tensor_images, classnum, downsample=2) + if discrete_pixels: # pixel loss: use mask instead of pred + add_effect = added_mask.float() + add_effect = -add_effect + add_downsampled = torch.nn.functional.adaptive_avg_pool2d( + add_effect[:,None,:,:], feature_shape)[:,0,:,:] + if fullimage_measurement: + add_loss = add_downsampled.mean() + else: + add_at_loc = add_downsampled.view(len(add_downsampled), -1 + )[torch.arange(len(add_downsampled)), ploc] + add_loss = add_at_loc.sum() + if run_backward: + add_loss.backward() + return erase_loss + add_loss + +def train_ablation(args, corpus, cachefile, model, segmenter, classnum, + initial_ablation=None): + progress = default_progress() + cachedir = os.path.dirname(cachefile) + snapdir = os.path.join(cachedir, 'snapshots') + os.makedirs(snapdir, exist_ok=True) + + # high_replacement = corpus.feature_99[None,:,None,None].cuda() + if '_h99' in args.variant: + high_replacement = corpus.feature_99[None,:,None,None].cuda() + elif '_tcm' in args.variant: + # variant: top-conditional-mean + high_replacement = ( + corpus.mean_present_feature[None,:,None,None].cuda()) + else: # default: weighted mean + high_replacement = ( + corpus.weighted_mean_present_feature[None,:,None,None].cuda()) + fullimage_measurement = False + ablation_only = False + fullimage_ablation = False + if '_fim' in args.variant: + fullimage_measurement = True + elif '_fia' in args.variant: + fullimage_measurement = True + ablation_only = True + fullimage_ablation = True + high_replacement.requires_grad = False + for p in model.parameters(): + p.requires_grad = False + + ablation = torch.zeros(high_replacement.shape).cuda() + if initial_ablation is not None: + ablation.view(-1)[...] = initial_ablation + ablation.requires_grad = True + optimizer = torch.optim.Adam([ablation], lr=0.01) + start_epoch = 0 + epoch = 0 + + def eval_loss_and_reg(): + discrete_experiments = dict( + # dpixel=dict(discrete_pixels=True), + # dunits20=dict(discrete_units=20), + # dumix20=dict(discrete_units=20, mixed_units=True), + # dunits10=dict(discrete_units=10), + # abonly=dict(ablation_only=True), + # fimabl=dict(ablation_only=True, + # fullimage_ablation=True, + # fullimage_measurement=True), + dboth20=dict(discrete_units=20, discrete_pixels=True), + # dbothm20=dict(discrete_units=20, mixed_units=True, + # discrete_pixels=True), + # abdisc20=dict(discrete_units=20, discrete_pixels=True, + # ablation_only=True), + # abdiscm20=dict(discrete_units=20, mixed_units=True, + # discrete_pixels=True, + # ablation_only=True), + # fimadp=dict(discrete_pixels=True, + # ablation_only=True, + # fullimage_ablation=True, + # fullimage_measurement=True), + # fimadu10=dict(discrete_units=10, + # ablation_only=True, + # fullimage_ablation=True, + # fullimage_measurement=True), + # fimadb10=dict(discrete_units=10, discrete_pixels=True, + # ablation_only=True, + # fullimage_ablation=True, + # fullimage_measurement=True), + fimadbm10=dict(discrete_units=10, mixed_units=True, + discrete_pixels=True, + ablation_only=True, + fullimage_ablation=True, + fullimage_measurement=True), + # fimadu20=dict(discrete_units=20, + # ablation_only=True, + # fullimage_ablation=True, + # fullimage_measurement=True), + # fimadb20=dict(discrete_units=20, discrete_pixels=True, + # ablation_only=True, + # fullimage_ablation=True, + # fullimage_measurement=True), + fimadbm20=dict(discrete_units=20, mixed_units=True, + discrete_pixels=True, + ablation_only=True, + fullimage_ablation=True, + fullimage_measurement=True) + ) + with torch.no_grad(): + total_loss = 0 + discrete_losses = {k: 0 for k in discrete_experiments} + for [pbatch, ploc, cbatch, cloc] in progress( + torch.utils.data.DataLoader(TensorDataset( + corpus.eval_present_sample, + corpus.eval_present_location, + corpus.eval_candidate_sample, + corpus.eval_candidate_location), + batch_size=args.inference_batch_size, num_workers=10, + shuffle=False, pin_memory=True), + desc="Eval"): + # First, put in zeros for the selected units. + # Loss is amount of remaining object. + total_loss = total_loss + ace_loss(segmenter, classnum, + model, args.layer, high_replacement, ablation, + pbatch, ploc, cbatch, cloc, run_backward=False, + ablation_only=ablation_only, + fullimage_measurement=fullimage_measurement) + for k, config in discrete_experiments.items(): + discrete_losses[k] = discrete_losses[k] + ace_loss( + segmenter, classnum, + model, args.layer, high_replacement, ablation, + pbatch, ploc, cbatch, cloc, run_backward=False, + **config) + avg_loss = (total_loss / args.eval_size).item() + avg_d_losses = {k: (d / args.eval_size).item() + for k, d in discrete_losses.items()} + regularizer = (args.l2_lambda * ablation.pow(2).sum()) + print_progress('Epoch %d Loss %g Regularizer %g' % + (epoch, avg_loss, regularizer)) + print_progress(' '.join('%s: %g' % (k, d) + for k, d in avg_d_losses.items())) + print_progress(scale_summary(ablation.view(-1), 10, 3)) + return avg_loss, regularizer, avg_d_losses + + if args.eval_only: + # For eval_only, just load each snapshot and re-run validation eval + # pass on each one. + for epoch in range(-1, args.train_epochs): + snapfile = os.path.join(snapdir, 'epoch-%d.pth' % epoch) + if not os.path.exists(snapfile): + data = {} + if epoch >= 0: + print('No epoch %d' % epoch) + continue + else: + data = torch.load(snapfile) + with torch.no_grad(): + ablation[...] = data['ablation'].to(ablation.device) + optimizer.load_state_dict(data['optimizer']) + avg_loss, regularizer, new_extra = eval_loss_and_reg() + # Keep old values, and update any new ones. + extra = {k: v for k, v in data.items() + if k not in ['ablation', 'optimizer', 'avg_loss']} + extra.update(new_extra) + torch.save(dict(ablation=ablation, optimizer=optimizer.state_dict(), + avg_loss=avg_loss, **extra), + os.path.join(snapdir, 'epoch-%d.pth' % epoch)) + # Return loaded ablation. + return ablation.view(-1).detach().cpu().numpy() + + if not args.no_cache: + for start_epoch in reversed(range(args.train_epochs)): + snapfile = os.path.join(snapdir, 'epoch-%d.pth' % start_epoch) + if os.path.exists(snapfile): + data = torch.load(snapfile) + with torch.no_grad(): + ablation[...] = data['ablation'].to(ablation.device) + optimizer.load_state_dict(data['optimizer']) + start_epoch += 1 + break + + if start_epoch < args.train_epochs: + epoch = start_epoch - 1 + avg_loss, regularizer, extra = eval_loss_and_reg() + if epoch == -1: + torch.save(dict(ablation=ablation, optimizer=optimizer.state_dict(), + avg_loss=avg_loss, **extra), + os.path.join(snapdir, 'epoch-%d.pth' % epoch)) + + update_size = args.train_update_freq * args.train_batch_size + for epoch in range(start_epoch, args.train_epochs): + candidate_shuffle = torch.randperm(len(corpus.candidate_sample)) + train_loss = 0 + for batch_num, [pbatch, ploc, cbatch, cloc] in enumerate(progress( + torch.utils.data.DataLoader(TensorDataset( + corpus.object_present_sample, + corpus.object_present_location, + corpus.candidate_sample[candidate_shuffle], + corpus.candidate_location[candidate_shuffle]), + batch_size=args.train_batch_size, num_workers=10, + shuffle=True, pin_memory=True), + desc="ACE opt epoch %d" % epoch)): + if batch_num % args.train_update_freq == 0: + optimizer.zero_grad() + # First, put in zeros for the selected units. Loss is amount + # of remaining object. + loss = ace_loss(segmenter, classnum, + model, args.layer, high_replacement, ablation, + pbatch, ploc, cbatch, cloc, run_backward=True, + ablation_only=ablation_only, + fullimage_measurement=fullimage_measurement) + with torch.no_grad(): + train_loss = train_loss + loss + if (batch_num + 1) % args.train_update_freq == 0: + # Third, add some L2 loss to encourage sparsity. + regularizer = (args.l2_lambda * update_size + * ablation.pow(2).sum()) + regularizer.backward() + optimizer.step() + with torch.no_grad(): + ablation.clamp_(0, 1) + post_progress(l=(train_loss/update_size).item(), + r=(regularizer/update_size).item()) + train_loss = 0 + + avg_loss, regularizer, extra = eval_loss_and_reg() + torch.save(dict(ablation=ablation, optimizer=optimizer.state_dict(), + avg_loss=avg_loss, **extra), + os.path.join(snapdir, 'epoch-%d.pth' % epoch)) + numpy.save(os.path.join(snapdir, 'epoch-%d.npy' % epoch), + ablation.detach().cpu().numpy()) + + # The output of this phase is this set of scores. + return ablation.view(-1).detach().cpu().numpy() + + +def tensor_to_numpy_image_batch(tensor_image): + byte_image = (((tensor_image+1)/2)*255).clamp(0, 255).byte() + numpy_image = byte_image.permute(0, 2, 3, 1).cpu().numpy() + return numpy_image + +# Phase 4: evaluation of intervention + +def evaluate_ablation(args, model, segmenter, eval_sample, classnum, layer, + ordering): + total_bincount = 0 + data_size = 0 + progress = default_progress() + for l in model.ablation: + model.ablation[l] = None + feature_units = model.feature_shape[args.layer][1] + feature_shape = model.feature_shape[args.layer][2:] + repeats = len(ordering) + total_scores = torch.zeros(repeats + 1) + for i, batch in enumerate(progress(torch.utils.data.DataLoader( + TensorDataset(eval_sample), + batch_size=args.inference_batch_size, num_workers=10, + pin_memory=True), + desc="Evaluate interventions")): + tensor_image = model(zbatch) + segmented_image = segmenter.segment_batch(tensor_image, + downsample=2) + mask = (segmented_image == classnum).max(1)[0] + downsampled_seg = torch.nn.functional.adaptive_avg_pool2d( + mask.float()[:,None,:,:], feature_shape)[:,0,:,:] + total_scores[0] += downsampled_seg.sum().cpu() + # Now we need to do an intervention for every location + # that had a nonzero downsampled_seg, if any. + interventions_needed = downsampled_seg.nonzero() + location_count = len(interventions_needed) + if location_count == 0: + continue + interventions_needed = interventions_needed.repeat(repeats, 1) + inter_z = batch[0][interventions_needed[:,0]].to(device) + inter_chan = torch.zeros(repeats, location_count, feature_units, + device=device) + for j, u in enumerate(ordering): + inter_chan[j:, :, u] = 1 + inter_chan = inter_chan.view(len(inter_z), feature_units) + inter_loc = interventions_needed[:,1:] + scores = torch.zeros(len(inter_z)) + batch_size = len(batch[0]) + for j in range(0, len(inter_z), batch_size): + ibz = inter_z[j:j+batch_size] + ibl = inter_loc[j:j+batch_size].t() + imask = torch.zeros((len(ibz),) + feature_shape, device=ibz.device) + imask[(torch.arange(len(ibz)),) + tuple(ibl)] = 1 + ibc = inter_chan[j:j+batch_size] + model.edit_layer(args.layer, ablation=( + imask.float()[:,None,:,:] * ibc[:,:,None,None])) + _, seg, _, _, _ = ( + recovery.recover_im_seg_bc_and_features( + [ibz], model)) + mask = (seg == classnum).max(1)[0] + downsampled_iseg = torch.nn.functional.adaptive_avg_pool2d( + mask.float()[:,None,:,:], feature_shape)[:,0,:,:] + scores[j:j+batch_size] = downsampled_iseg[ + (torch.arange(len(ibz)),) + tuple(ibl)] + scores = scores.view(repeats, location_count).sum(1) + total_scores[1:] += scores + return total_scores + +def evaluate_interventions(args, model, segmenter, eval_sample, + classnum, layer, units): + total_bincount = 0 + data_size = 0 + progress = default_progress() + for l in model.ablation: + model.ablation[l] = None + feature_units = model.feature_shape[args.layer][1] + feature_shape = model.feature_shape[args.layer][2:] + repeats = len(ordering) + total_scores = torch.zeros(repeats + 1) + for i, batch in enumerate(progress(torch.utils.data.DataLoader( + TensorDataset(eval_sample), + batch_size=args.inference_batch_size, num_workers=10, + pin_memory=True), + desc="Evaluate interventions")): + tensor_image = model(zbatch) + segmented_image = segmenter.segment_batch(tensor_image, + downsample=2) + mask = (segmented_image == classnum).max(1)[0] + downsampled_seg = torch.nn.functional.adaptive_avg_pool2d( + mask.float()[:,None,:,:], feature_shape)[:,0,:,:] + total_scores[0] += downsampled_seg.sum().cpu() + # Now we need to do an intervention for every location + # that had a nonzero downsampled_seg, if any. + interventions_needed = downsampled_seg.nonzero() + location_count = len(interventions_needed) + if location_count == 0: + continue + interventions_needed = interventions_needed.repeat(repeats, 1) + inter_z = batch[0][interventions_needed[:,0]].to(device) + inter_chan = torch.zeros(repeats, location_count, feature_units, + device=device) + for j, u in enumerate(ordering): + inter_chan[j:, :, u] = 1 + inter_chan = inter_chan.view(len(inter_z), feature_units) + inter_loc = interventions_needed[:,1:] + scores = torch.zeros(len(inter_z)) + batch_size = len(batch[0]) + for j in range(0, len(inter_z), batch_size): + ibz = inter_z[j:j+batch_size] + ibl = inter_loc[j:j+batch_size].t() + imask = torch.zeros((len(ibz),) + feature_shape, device=ibz.device) + imask[(torch.arange(len(ibz)),) + tuple(ibl)] = 1 + ibc = inter_chan[j:j+batch_size] + model.ablation[args.layer] = ( + imask.float()[:,None,:,:] * ibc[:,:,None,None]) + _, seg, _, _, _ = ( + recovery.recover_im_seg_bc_and_features( + [ibz], model)) + mask = (seg == classnum).max(1)[0] + downsampled_iseg = torch.nn.functional.adaptive_avg_pool2d( + mask.float()[:,None,:,:], feature_shape)[:,0,:,:] + scores[j:j+batch_size] = downsampled_iseg[ + (torch.arange(len(ibz)),) + tuple(ibl)] + scores = scores.view(repeats, location_count).sum(1) + total_scores[1:] += scores + return total_scores + + +def add_ace_ranking_to_dissection(outdir, layer, classname, total_scores): + source_filename = os.path.join(outdir, 'dissect.json') + source_filename_bak = os.path.join(outdir, 'dissect.json.bak') + + # Back up the dissection (if not already backed up) before modifying + if not os.path.exists(source_filename_bak): + shutil.copy(source_filename, source_filename_bak) + + with open(source_filename) as f: + dissection = EasyDict(json.load(f)) + + ranking_name = '%s-ace' % classname + + # Remove any old ace ranking with the same name + lrec = [l for l in dissection.layers if l.layer == layer][0] + lrec.rankings = [r for r in lrec.rankings if r.name != ranking_name] + + # Now convert ace scores to rankings + new_rankings = [dict( + name=ranking_name, + score=(-total_scores).flatten().tolist(), + metric='ace')] + + # Prepend to list. + lrec.rankings[2:2] = new_rankings + + # Replace the old dissect.json in-place + with open(source_filename, 'w') as f: + json.dump(dissection, f, indent=1) + +def summarize_scores(args, corpus, cachedir, layer, classname, variant, scores): + target_filename = os.path.join(cachedir, 'summary.json') + + ranking_name = '%s-%s' % (classname, variant) + # Now convert ace scores to rankings + new_rankings = [dict( + name=ranking_name, + score=(-scores).flatten().tolist(), + metric=variant)] + result = dict(layers=[dict(layer=layer, rankings=new_rankings)]) + + # Replace the old dissect.json in-place + with open(target_filename, 'w') as f: + json.dump(result, f, indent=1) + +if __name__ == '__main__': + main() diff --git a/netdissect/aceplotablate.py b/netdissect/aceplotablate.py new file mode 100644 index 0000000000000000000000000000000000000000..585195eaf973760a7d78e4da6539c343049141de --- /dev/null +++ b/netdissect/aceplotablate.py @@ -0,0 +1,54 @@ +import os, sys, argparse, json, shutil +from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas +from matplotlib.figure import Figure +from matplotlib.ticker import MaxNLocator +import matplotlib + +def main(): + parser = argparse.ArgumentParser(description='ACE optimization utility', + prog='python -m netdissect.aceoptimize') + parser.add_argument('--classname', type=str, default=None, + help='intervention classname') + parser.add_argument('--layer', type=str, default='layer4', + help='layer name') + parser.add_argument('--outdir', type=str, default=None, + help='dissection directory') + parser.add_argument('--metric', type=str, default=None, + help='experiment variant') + args = parser.parse_args() + + if args.metric is None: + args.metric = 'ace' + + run_command(args) + +def run_command(args): + fig = Figure(figsize=(4.5,3.5)) + FigureCanvas(fig) + ax = fig.add_subplot(111) + for metric in [args.metric, 'iou']: + jsonname = os.path.join(args.outdir, args.layer, 'fullablation', + '%s-%s.json' % (args.classname, metric)) + with open(jsonname) as f: + summary = json.load(f) + baseline = summary['baseline'] + effects = summary['ablation_effects'][:26] + norm_effects = [0] + [1.0 - e / baseline for e in effects] + ax.plot(norm_effects, label= + 'Units by ACE' if 'ace' in metric else 'Top units by IoU') + ax.set_title('Effect of ablating units for %s' % (args.classname)) + ax.grid(True) + ax.legend() + ax.set_ylabel('Portion of %s pixels removed' % args.classname) + ax.set_xlabel('Number of units ablated') + ax.set_ylim(0, 1.0) + ax.set_xlim(0, 25) + fig.tight_layout() + dirname = os.path.join(args.outdir, args.layer, 'fullablation') + fig.savefig(os.path.join(dirname, 'effect-%s-%s.png' % + (args.classname, args.metric))) + fig.savefig(os.path.join(dirname, 'effect-%s-%s.pdf' % + (args.classname, args.metric))) + +if __name__ == '__main__': + main() diff --git a/netdissect/acesummarize.py b/netdissect/acesummarize.py new file mode 100644 index 0000000000000000000000000000000000000000..345129245b461f44ef58538f02a08c3684d33f31 --- /dev/null +++ b/netdissect/acesummarize.py @@ -0,0 +1,62 @@ +import os, sys, numpy, torch, argparse, skimage, json, shutil +from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas +from matplotlib.figure import Figure +from matplotlib.ticker import MaxNLocator +import matplotlib + +def main(): + parser = argparse.ArgumentParser(description='ACE optimization utility', + prog='python -m netdissect.aceoptimize') + parser.add_argument('--classname', type=str, default=None, + help='intervention classname') + parser.add_argument('--layer', type=str, default='layer4', + help='layer name') + parser.add_argument('--l2_lambda', type=float, nargs='+', + help='l2 regularizer hyperparameter') + parser.add_argument('--outdir', type=str, default=None, + help='dissection directory') + parser.add_argument('--variant', type=str, default=None, + help='experiment variant') + args = parser.parse_args() + + if args.variant is None: + args.variant = 'ace' + + run_command(args) + +def run_command(args): + fig = Figure(figsize=(4.5,3.5)) + FigureCanvas(fig) + ax = fig.add_subplot(111) + for l2_lambda in args.l2_lambda: + variant = args.variant + if l2_lambda != 0.01: + variant += '_reg%g' % l2_lambda + + dirname = os.path.join(args.outdir, args.layer, variant, args.classname) + snapshots = os.path.join(dirname, 'snapshots') + try: + dat = [torch.load(os.path.join(snapshots, 'epoch-%d.pth' % i)) + for i in range(10)] + except: + print('Missing %s snapshots' % dirname) + return + print('reg %g' % l2_lambda) + for i in range(10): + print(i, dat[i]['avg_loss'], + len((dat[i]['ablation'] == 1).nonzero())) + + ax.plot([dat[i]['avg_loss'] for i in range(10)], + label='reg %g' % l2_lambda) + ax.set_title('%s %s' % (args.classname, args.variant)) + ax.grid(True) + ax.legend() + ax.set_ylabel('Loss') + ax.set_xlabel('Epochs') + fig.tight_layout() + dirname = os.path.join(args.outdir, args.layer, + args.variant, args.classname) + fig.savefig(os.path.join(dirname, 'loss-plot.png')) + +if __name__ == '__main__': + main() diff --git a/netdissect/actviz.py b/netdissect/actviz.py new file mode 100644 index 0000000000000000000000000000000000000000..060ea13d589544ce936ac7c7bc20cd35194d0ae9 --- /dev/null +++ b/netdissect/actviz.py @@ -0,0 +1,187 @@ +import os +import numpy +from scipy.interpolate import RectBivariateSpline + +def activation_visualization(image, data, level, alpha=0.5, source_shape=None, + crop=False, zoom=None, border=2, negate=False, return_mask=False, + **kwargs): + """ + Makes a visualiztion image of activation data overlaid on the image. + Params: + image The original image. + data The single channel feature map. + alpha The darkening to apply in inactive regions of the image. + level The threshold of activation levels to highlight. + """ + if len(image.shape) == 2: + # Puff up grayscale image to RGB. + image = image[:,:,None] * numpy.array([[[1, 1, 1]]]) + surface = activation_surface(data, target_shape=image.shape[:2], + source_shape=source_shape, **kwargs) + if negate: + surface = -surface + level = -level + if crop: + # crop to source_shape + if source_shape is not None: + ch, cw = ((t - s) // 2 for s, t in zip( + source_shape, image.shape[:2])) + image = image[ch:ch+source_shape[0], cw:cw+source_shape[1]] + surface = surface[ch:ch+source_shape[0], cw:cw+source_shape[1]] + if crop is True: + crop = surface.shape + elif not hasattr(crop, '__len__'): + crop = (crop, crop) + if zoom is not None: + source_rect = best_sub_rect(surface >= level, crop, zoom, + pad=border) + else: + source_rect = (0, surface.shape[0], 0, surface.shape[1]) + image = zoom_image(image, source_rect, crop) + surface = zoom_image(surface, source_rect, crop) + mask = (surface >= level) + # Add a yellow border at the edge of the mask for contrast + result = (mask[:, :, None] * (1 - alpha) + alpha) * image + if border: + edge = mask_border(mask)[:,:,None] + result = numpy.maximum(edge * numpy.array([[[200, 200, 0]]]), result) + if not return_mask: + return result + mask_image = (1 - mask[:, :, None]) * numpy.array( + [[[0, 0, 0, 255 * (1 - alpha)]]], dtype=numpy.uint8) + if border: + mask_image = numpy.maximum(edge * numpy.array([[[200, 200, 0, 255]]]), + mask_image) + return result, mask_image + +def activation_surface(data, target_shape=None, source_shape=None, + scale_offset=None, deg=1, pad=True): + """ + Generates an upsampled activation sample. + Params: + target_shape Shape of the output array. + source_shape The centered shape of the output to match with data + when upscaling. Defaults to the whole target_shape. + scale_offset The amount by which to scale, then offset data + dimensions to end up with target dimensions. A pair of pairs. + deg Degree of interpolation to apply (1 = linear, etc). + pad True to zero-pad the edge instead of doing a funny edge interp. + """ + # Default is that nothing is resized. + if target_shape is None: + target_shape = data.shape + # Make a default scale_offset to fill the image if there isn't one + if scale_offset is None: + scale = tuple(float(ts) / ds + for ts, ds in zip(target_shape, data.shape)) + offset = tuple(0.5 * s - 0.5 for s in scale) + else: + scale, offset = (v for v in zip(*scale_offset)) + # Now we adjust offsets to take into account cropping and so on + if source_shape is not None: + offset = tuple(o + (ts - ss) / 2.0 + for o, ss, ts in zip(offset, source_shape, target_shape)) + # Pad the edge with zeros for sensible edge behavior + if pad: + zeropad = numpy.zeros( + (data.shape[0] + 2, data.shape[1] + 2), dtype=data.dtype) + zeropad[1:-1, 1:-1] = data + data = zeropad + offset = tuple((o - s) for o, s in zip(offset, scale)) + # Upsample linearly + ty, tx = (numpy.arange(ts) for ts in target_shape) + sy, sx = (numpy.arange(ss) * s + o + for ss, s, o in zip(data.shape, scale, offset)) + levels = RectBivariateSpline( + sy, sx, data, kx=deg, ky=deg)(ty, tx, grid=True) + # Return the mask. + return levels + +def mask_border(mask, border=2): + """Given a mask computes a border mask""" + from scipy import ndimage + struct = ndimage.generate_binary_structure(2, 2) + erosion = numpy.ones((mask.shape[0] + 10, mask.shape[1] + 10), dtype='int') + erosion[5:5+mask.shape[0], 5:5+mask.shape[1]] = ~mask + for _ in range(border): + erosion = ndimage.binary_erosion(erosion, struct) + return ~mask ^ erosion[5:5+mask.shape[0], 5:5+mask.shape[1]] + +def bounding_rect(mask, pad=0): + """Returns (r, b, l, r) boundaries so that all nonzero pixels in mask + have locations (i, j) with t <= i < b, and l <= j < r.""" + nz = mask.nonzero() + if len(nz[0]) == 0: + # print('no pixels') + return (0, mask.shape[0], 0, mask.shape[1]) + (t, b), (l, r) = [(max(0, p.min() - pad), min(s, p.max() + 1 + pad)) + for p, s in zip(nz, mask.shape)] + return (t, b, l, r) + +def best_sub_rect(mask, shape, max_zoom=None, pad=2): + """Finds the smallest subrectangle containing all the nonzeros of mask, + matching the aspect ratio of shape, and where the zoom-up ratio is no + more than max_zoom""" + t, b, l, r = bounding_rect(mask, pad=pad) + height = max(b - t, int(round(float(shape[0]) * (r - l) / shape[1]))) + if max_zoom is not None: + height = int(max(round(float(shape[0]) / max_zoom), height)) + width = int(round(float(shape[1]) * height / shape[0])) + nt = min(mask.shape[0] - height, max(0, (b + t - height) // 2)) + nb = nt + height + nl = min(mask.shape[1] - width, max(0, (r + l - width) // 2)) + nr = nl + width + return (nt, nb, nl, nr) + +def zoom_image(img, source_rect, target_shape=None): + """Zooms pixels from the source_rect of img to target_shape.""" + import warnings + from scipy.ndimage import zoom + if target_shape is None: + target_shape = img.shape + st, sb, sl, sr = source_rect + source = img[st:sb, sl:sr] + if source.shape == target_shape: + return source + zoom_tuple = tuple(float(t) / s + for t, s in zip(target_shape, source.shape[:2]) + ) + (1,) * (img.ndim - 2) + with warnings.catch_warnings(): + warnings.simplefilter('ignore', UserWarning) # "output shape of zoom" + target = zoom(source, zoom_tuple) + assert target.shape[:2] == target_shape, (target.shape, target_shape) + return target + +def scale_offset(dilations): + if len(dilations) == 0: + return (1, 0) + scale, offset = scale_offset(dilations[1:]) + kernel, stride, padding = dilations[0] + scale *= stride + offset *= stride + offset += (kernel - 1) / 2.0 - padding + return scale, offset + +def choose_level(feature_map, percentile=0.8): + ''' + Chooses the top 80% level (or whatever the level chosen). + ''' + data_range = numpy.sort(feature_map.flatten()) + return numpy.interp( + percentile, numpy.linspace(0, 1, len(data_range)), data_range) + +def dilations(modulelist): + result = [] + for module in modulelist: + settings = tuple(getattr(module, n, d) + for n, d in (('kernel_size', 1), ('stride', 1), ('padding', 0))) + settings = (((s, s) if not isinstance(s, tuple) else s) + for s in settings) + if settings != ((1, 1), (1, 1), (0, 0)): + result.append(zip(*settings)) + return zip(*result) + +def grid_scale_offset(modulelist): + '''Returns (yscale, yoffset), (xscale, xoffset) given a list of modules''' + return tuple(scale_offset(d) for d in dilations(modulelist)) + diff --git a/netdissect/autoeval.py b/netdissect/autoeval.py new file mode 100644 index 0000000000000000000000000000000000000000..ecc86a1f7b403f57821dde2a2b4f0619c0d6cae3 --- /dev/null +++ b/netdissect/autoeval.py @@ -0,0 +1,37 @@ +from collections import defaultdict +from importlib import import_module + +def autoimport_eval(term): + ''' + Used to evaluate an arbitrary command-line constructor specifying + a class, with automatic import of global module names. + ''' + + class DictNamespace(object): + def __init__(self, d): + self.__d__ = d + def __getattr__(self, key): + return self.__d__[key] + + class AutoImportDict(defaultdict): + def __init__(self, wrapped=None, parent=None): + super().__init__() + self.wrapped = wrapped + self.parent = parent + def __missing__(self, key): + if self.wrapped is not None: + if key in self.wrapped: + return self.wrapped[key] + if self.parent is not None: + key = self.parent + '.' + key + if key in __builtins__: + return __builtins__[key] + mdl = import_module(key) + # Return an AutoImportDict for any namespace packages + if hasattr(mdl, '__path__'): # and not hasattr(mdl, '__file__'): + return DictNamespace( + AutoImportDict(wrapped=mdl.__dict__, parent=key)) + return mdl + + return eval(term, {}, AutoImportDict()) + diff --git a/netdissect/broden.py b/netdissect/broden.py new file mode 100644 index 0000000000000000000000000000000000000000..854e87a46839c837b43cba5347967ce74ae4bf35 --- /dev/null +++ b/netdissect/broden.py @@ -0,0 +1,271 @@ +import os, errno, numpy, torch, csv, re, shutil, os, zipfile +from collections import OrderedDict +from torchvision.datasets.folder import default_loader +from torchvision import transforms +from scipy import ndimage +from urllib.request import urlopen + +class BrodenDataset(torch.utils.data.Dataset): + ''' + A multicategory segmentation data set. + + Returns three streams: + (1) The image (3, h, w). + (2) The multicategory segmentation (labelcount, h, w). + (3) A bincount of pixels in the segmentation (labelcount). + + Net dissect also assumes that the dataset object has three properties + with human-readable labels: + + ds.labels = ['red', 'black', 'car', 'tree', 'grid', ...] + ds.categories = ['color', 'part', 'object', 'texture'] + ds.label_category = [0, 0, 2, 2, 3, ...] # The category for each label + ''' + def __init__(self, directory='dataset/broden', resolution=384, + split='train', categories=None, + transform=None, transform_segment=None, + download=False, size=None, include_bincount=True, + broden_version=1, max_segment_depth=6): + assert resolution in [224, 227, 384] + if download: + ensure_broden_downloaded(directory, resolution, broden_version) + self.directory = directory + self.resolution = resolution + self.resdir = os.path.join(directory, 'broden%d_%d' % + (broden_version, resolution)) + self.loader = default_loader + self.transform = transform + self.transform_segment = transform_segment + self.include_bincount = include_bincount + # The maximum number of multilabel layers that coexist at an image. + self.max_segment_depth = max_segment_depth + with open(os.path.join(self.resdir, 'category.csv'), + encoding='utf-8') as f: + self.category_info = OrderedDict() + for row in csv.DictReader(f): + self.category_info[row['name']] = row + if categories is not None: + # Filter out unused categories + categories = set([c for c in categories if c in self.category_info]) + for cat in list(self.category_info.keys()): + if cat not in categories: + del self.category_info[cat] + categories = list(self.category_info.keys()) + self.categories = categories + + # Filter out unneeded images. + with open(os.path.join(self.resdir, 'index.csv'), + encoding='utf-8') as f: + all_images = [decode_index_dict(r) for r in csv.DictReader(f)] + self.image = [row for row in all_images + if index_has_any_data(row, categories) and row['split'] == split] + if size is not None: + self.image = self.image[:size] + with open(os.path.join(self.resdir, 'label.csv'), + encoding='utf-8') as f: + self.label_info = build_dense_label_array([ + decode_label_dict(r) for r in csv.DictReader(f)]) + self.labels = [l['name'] for l in self.label_info] + # Build dense remapping arrays for labels, so that you can + # get dense ranges of labels for each category. + self.category_map = {} + self.category_unmap = {} + self.category_label = {} + for cat in self.categories: + with open(os.path.join(self.resdir, 'c_%s.csv' % cat), + encoding='utf-8') as f: + c_data = [decode_label_dict(r) for r in csv.DictReader(f)] + self.category_unmap[cat], self.category_map[cat] = ( + build_numpy_category_map(c_data)) + self.category_label[cat] = build_dense_label_array( + c_data, key='code') + self.num_labels = len(self.labels) + # Primary categories for each label is the category in which it + # appears with the maximum coverage. + self.label_category = numpy.zeros(self.num_labels, dtype=int) + for i in range(self.num_labels): + maxcoverage, self.label_category[i] = max( + (self.category_label[cat][self.category_map[cat][i]]['coverage'] + if i < len(self.category_map[cat]) + and self.category_map[cat][i] else 0, ic) + for ic, cat in enumerate(categories)) + + def __len__(self): + return len(self.image) + + def __getitem__(self, idx): + record = self.image[idx] + # example record: { + # 'image': 'opensurfaces/25605.jpg', 'split': 'train', + # 'ih': 384, 'iw': 384, 'sh': 192, 'sw': 192, + # 'color': ['opensurfaces/25605_color.png'], + # 'object': [], 'part': [], + # 'material': ['opensurfaces/25605_material.png'], + # 'scene': [], 'texture': []} + image = self.loader(os.path.join(self.resdir, 'images', + record['image'])) + segment = numpy.zeros(shape=(self.max_segment_depth, + record['sh'], record['sw']), dtype=int) + if self.include_bincount: + bincount = numpy.zeros(shape=(self.num_labels,), dtype=int) + depth = 0 + for cat in self.categories: + for layer in record[cat]: + if isinstance(layer, int): + segment[depth,:,:] = layer + if self.include_bincount: + bincount[layer] += segment.shape[1] * segment.shape[2] + else: + png = numpy.asarray(self.loader(os.path.join( + self.resdir, 'images', layer))) + segment[depth,:,:] = png[:,:,0] + png[:,:,1] * 256 + if self.include_bincount: + bincount += numpy.bincount(segment[depth,:,:].flatten(), + minlength=self.num_labels) + depth += 1 + if self.transform: + image = self.transform(image) + if self.transform_segment: + segment = self.transform_segment(segment) + if self.include_bincount: + bincount[0] = 0 + return (image, segment, bincount) + else: + return (image, segment) + +def build_dense_label_array(label_data, key='number', allow_none=False): + ''' + Input: set of rows with 'number' fields (or another field name key). + Output: array such that a[number] = the row with the given number. + ''' + result = [None] * (max([d[key] for d in label_data]) + 1) + for d in label_data: + result[d[key]] = d + # Fill in none + if not allow_none: + example = label_data[0] + def make_empty(k): + return dict((c, k if c is key else type(v)()) + for c, v in example.items()) + for i, d in enumerate(result): + if d is None: + result[i] = dict(make_empty(i)) + return result + +def build_numpy_category_map(map_data, key1='code', key2='number'): + ''' + Input: set of rows with 'number' fields (or another field name key). + Output: array such that a[number] = the row with the given number. + ''' + results = list(numpy.zeros((max([d[key] for d in map_data]) + 1), + dtype=numpy.int16) for key in (key1, key2)) + for d in map_data: + results[0][d[key1]] = d[key2] + results[1][d[key2]] = d[key1] + return results + +def index_has_any_data(row, categories): + for c in categories: + for data in row[c]: + if data: return True + return False + +def decode_label_dict(row): + result = {} + for key, val in row.items(): + if key == 'category': + result[key] = dict((c, int(n)) + for c, n in [re.match('^([^(]*)\(([^)]*)\)$', f).groups() + for f in val.split(';')]) + elif key == 'name': + result[key] = val + elif key == 'syns': + result[key] = val.split(';') + elif re.match('^\d+$', val): + result[key] = int(val) + elif re.match('^\d+\.\d*$', val): + result[key] = float(val) + else: + result[key] = val + return result + +def decode_index_dict(row): + result = {} + for key, val in row.items(): + if key in ['image', 'split']: + result[key] = val + elif key in ['sw', 'sh', 'iw', 'ih']: + result[key] = int(val) + else: + item = [s for s in val.split(';') if s] + for i, v in enumerate(item): + if re.match('^\d+$', v): + item[i] = int(v) + result[key] = item + return result + +class ScaleSegmentation: + ''' + Utility for scaling segmentations, using nearest-neighbor zooming. + ''' + def __init__(self, target_height, target_width): + self.target_height = target_height + self.target_width = target_width + def __call__(self, seg): + ratio = (1, self.target_height / float(seg.shape[1]), + self.target_width / float(seg.shape[2])) + return ndimage.zoom(seg, ratio, order=0) + +def scatter_batch(seg, num_labels, omit_zero=True, dtype=torch.uint8): + ''' + Utility for scattering semgentations into a one-hot representation. + ''' + result = torch.zeros(*((seg.shape[0], num_labels,) + seg.shape[2:]), + dtype=dtype, device=seg.device) + result.scatter_(1, seg, 1) + if omit_zero: + result[:,0] = 0 + return result + +def ensure_broden_downloaded(directory, resolution, broden_version=1): + assert resolution in [224, 227, 384] + baseurl = 'http://netdissect.csail.mit.edu/data/' + dirname = 'broden%d_%d' % (broden_version, resolution) + if os.path.isfile(os.path.join(directory, dirname, 'index.csv')): + return # Already downloaded + zipfilename = 'broden1_%d.zip' % resolution + download_dir = os.path.join(directory, 'download') + os.makedirs(download_dir, exist_ok=True) + full_zipfilename = os.path.join(download_dir, zipfilename) + if not os.path.exists(full_zipfilename): + url = '%s/%s' % (baseurl, zipfilename) + print('Downloading %s' % url) + data = urlopen(url) + with open(full_zipfilename, 'wb') as f: + f.write(data.read()) + print('Unzipping %s' % zipfilename) + with zipfile.ZipFile(full_zipfilename, 'r') as zip_ref: + zip_ref.extractall(directory) + assert os.path.isfile(os.path.join(directory, dirname, 'index.csv')) + +def test_broden_dataset(): + ''' + Testing code. + ''' + bds = BrodenDataset('dataset/broden', resolution=384, + transform=transforms.Compose([ + transforms.Resize(224), + transforms.ToTensor()]), + transform_segment=transforms.Compose([ + ScaleSegmentation(224, 224) + ]), + include_bincount=True) + loader = torch.utils.data.DataLoader(bds, batch_size=100, num_workers=24) + for i in range(1,20): + print(bds.label[i]['name'], + list(bds.category.keys())[bds.primary_category[i]]) + for i, (im, seg, bc) in enumerate(loader): + print(i, im.shape, seg.shape, seg.max(), bc.shape) + +if __name__ == '__main__': + test_broden_dataset() diff --git a/netdissect/dissect.html b/netdissect/dissect.html new file mode 100644 index 0000000000000000000000000000000000000000..e6bf4e9a418abdfef5ba09c4182bd71cf1420e52 --- /dev/null +++ b/netdissect/dissect.html @@ -0,0 +1,399 @@ + + + + + + + + + + + + +
+ + + +
+
+ + + +
+ +
+
+{{lrec.interpretable}}/{{lrec.units.length}} units + +covering {{lrec.labels.length}} concepts +with IoU ≥ {{dissect.iou_threshold}} + +
+ +
+sort by + +{{rank.name}} + + + +
+
+ *-{{ metric }} +
+
+
+ {{rank.name}} +
+
+
+ + + +
+ +
+
+
{{urec[lk+'_label']}}
+
{{lrec.layer}} unit {{urec.unit}} ({{urec[lk+'_cat']}}) iou {{urec[lk + '_iou'] | fixed(2)}} {{lk}} {{urec[lk] | fixed(2)}}
+
+
+ +
+ +
+ + + + + + + diff --git a/netdissect/dissection.py b/netdissect/dissection.py new file mode 100644 index 0000000000000000000000000000000000000000..6eef0dfd0b8804e45eb878aca68e72f8c6493474 --- /dev/null +++ b/netdissect/dissection.py @@ -0,0 +1,1617 @@ +''' +To run dissection: + +1. Load up the convolutional model you wish to dissect, and wrap it in + an InstrumentedModel; then call imodel.retain_layers([layernames,..]) + to instrument the layers of interest. +2. Load the segmentation dataset using the BrodenDataset class; + use the transform_image argument to normalize images to be + suitable for the model, or the size argument to truncate the dataset. +3. Choose a directory in which to write the output, and call + dissect(outdir, model, dataset). + +Example: + + from dissect import InstrumentedModel, dissect + from broden import BrodenDataset + + model = InstrumentedModel(load_my_model()) + model.eval() + model.cuda() + model.retain_layers(['conv1', 'conv2', 'conv3', 'conv4', 'conv5']) + bds = BrodenDataset('dataset/broden1_227', + transform_image=transforms.Compose([ + transforms.ToTensor(), + transforms.Normalize(IMAGE_MEAN, IMAGE_STDEV)]), + size=1000) + dissect('result/dissect', model, bds, + examples_per_unit=10) +''' + +import torch, numpy, os, re, json, shutil, types, tempfile, torchvision +# import warnings +# warnings.simplefilter('error', UserWarning) +from PIL import Image +from xml.etree import ElementTree as et +from collections import OrderedDict, defaultdict +from .progress import verbose_progress, default_progress, print_progress +from .progress import desc_progress +from .runningstats import RunningQuantile, RunningTopK +from .runningstats import RunningCrossCovariance, RunningConditionalQuantile +from .sampler import FixedSubsetSampler +from .actviz import activation_visualization +from .segviz import segment_visualization, high_contrast +from .workerpool import WorkerBase, WorkerPool +from .segmenter import UnifiedParsingSegmenter + +def dissect(outdir, model, dataset, + segrunner=None, + train_dataset=None, + model_segmenter=None, + quantile_threshold=0.005, + iou_threshold=0.05, + iqr_threshold=0.01, + examples_per_unit=100, + batch_size=100, + num_workers=24, + seg_batch_size=5, + make_images=True, + make_labels=True, + make_maxiou=False, + make_covariance=False, + make_report=True, + make_row_images=True, + make_single_images=False, + rank_all_labels=False, + netname=None, + meta=None, + merge=None, + settings=None, + ): + ''' + Runs net dissection in-memory, using pytorch, and saves visualizations + and metadata into outdir. + ''' + assert not model.training, 'Run model.eval() before dissection' + if netname is None: + netname = type(model).__name__ + if segrunner is None: + segrunner = ClassifierSegRunner(dataset) + if train_dataset is None: + train_dataset = dataset + make_iqr = (quantile_threshold == 'iqr') + with torch.no_grad(): + device = next(model.parameters()).device + levels = None + labelnames, catnames = None, None + maxioudata, iqrdata = None, None + labeldata = None + iqrdata, cov = None, None + + labelnames, catnames = segrunner.get_label_and_category_names() + label_category = [catnames.index(c) if c in catnames else 0 + for l, c in labelnames] + + # First, always collect qunatiles and topk information. + segloader = torch.utils.data.DataLoader(dataset, + batch_size=batch_size, num_workers=num_workers, + pin_memory=(device.type == 'cuda')) + quantiles, topk = collect_quantiles_and_topk(outdir, model, + segloader, segrunner, k=examples_per_unit) + + # Thresholds can be automatically chosen by maximizing iqr + if make_iqr: + # Get thresholds based on an IQR optimization + segloader = torch.utils.data.DataLoader(train_dataset, + batch_size=1, num_workers=num_workers, + pin_memory=(device.type == 'cuda')) + iqrdata = collect_iqr(outdir, model, segloader, segrunner) + max_iqr, full_iqr_levels = iqrdata[:2] + max_iqr_agreement = iqrdata[4] + # qualified_iqr[max_iqr_quantile[layer] > 0.5] = 0 + levels = {layer: full_iqr_levels[layer][ + max_iqr[layer].max(0)[1], + torch.arange(max_iqr[layer].shape[1])].to(device) + for layer in full_iqr_levels} + else: + levels = {k: qc.quantiles([1.0 - quantile_threshold])[:,0] + for k, qc in quantiles.items()} + + quantiledata = (topk, quantiles, levels, quantile_threshold) + + if make_images: + segloader = torch.utils.data.DataLoader(dataset, + batch_size=batch_size, num_workers=num_workers, + pin_memory=(device.type == 'cuda')) + generate_images(outdir, model, dataset, topk, levels, segrunner, + row_length=examples_per_unit, batch_size=seg_batch_size, + row_images=make_row_images, + single_images=make_single_images, + num_workers=num_workers) + + if make_maxiou: + assert train_dataset, "Need training dataset for maxiou." + segloader = torch.utils.data.DataLoader(train_dataset, + batch_size=1, num_workers=num_workers, + pin_memory=(device.type == 'cuda')) + maxioudata = collect_maxiou(outdir, model, segloader, + segrunner) + + if make_labels: + segloader = torch.utils.data.DataLoader(dataset, + batch_size=1, num_workers=num_workers, + pin_memory=(device.type == 'cuda')) + iou_scores, iqr_scores, tcs, lcs, ccs, ics = ( + collect_bincounts(outdir, model, segloader, + levels, segrunner)) + labeldata = (iou_scores, iqr_scores, lcs, ccs, ics, iou_threshold, + iqr_threshold) + + if make_covariance: + segloader = torch.utils.data.DataLoader(dataset, + batch_size=seg_batch_size, + num_workers=num_workers, + pin_memory=(device.type == 'cuda')) + cov = collect_covariance(outdir, model, segloader, segrunner) + + if make_report: + generate_report(outdir, + quantiledata=quantiledata, + labelnames=labelnames, + catnames=catnames, + labeldata=labeldata, + maxioudata=maxioudata, + iqrdata=iqrdata, + covariancedata=cov, + rank_all_labels=rank_all_labels, + netname=netname, + meta=meta, + mergedata=merge, + settings=settings) + + return quantiledata, labeldata + +def generate_report(outdir, quantiledata, labelnames=None, catnames=None, + labeldata=None, maxioudata=None, iqrdata=None, covariancedata=None, + rank_all_labels=False, netname='Model', meta=None, settings=None, + mergedata=None): + ''' + Creates dissection.json reports and summary bargraph.svg files in the + specified output directory, and copies a dissection.html interface + to go along with it. + ''' + all_layers = [] + # Current source code directory, for html to copy. + srcdir = os.path.realpath( + os.path.join(os.getcwd(), os.path.dirname(__file__))) + # Unpack arguments + topk, quantiles, levels, quantile_threshold = quantiledata + top_record = dict( + netname=netname, + meta=meta, + default_ranking='unit', + quantile_threshold=quantile_threshold) + if settings is not None: + top_record['settings'] = settings + if labeldata is not None: + iou_scores, iqr_scores, lcs, ccs, ics, iou_threshold, iqr_threshold = ( + labeldata) + catorder = {'object': -7, 'scene': -6, 'part': -5, + 'piece': -4, + 'material': -3, 'texture': -2, 'color': -1} + for i, cat in enumerate(c for c in catnames if c not in catorder): + catorder[cat] = i + catnumber = {n: i for i, n in enumerate(catnames)} + catnumber['-'] = 0 + top_record['default_ranking'] = 'label' + top_record['iou_threshold'] = iou_threshold + top_record['iqr_threshold'] = iqr_threshold + labelnumber = dict((name[0], num) + for num, name in enumerate(labelnames)) + # Make a segmentation color dictionary + segcolors = {} + for i, name in enumerate(labelnames): + key = ','.join(str(s) for s in high_contrast[i % len(high_contrast)]) + if key in segcolors: + segcolors[key] += '/' + name[0] + else: + segcolors[key] = name[0] + top_record['segcolors'] = segcolors + for layer in topk.keys(): + units, rankings = [], [] + record = dict(layer=layer, units=units, rankings=rankings) + # For every unit, we always have basic visualization information. + topa, topi = topk[layer].result() + lev = levels[layer] + for u in range(len(topa)): + units.append(dict( + unit=u, + interp=True, + level=lev[u].item(), + top=[dict(imgnum=i.item(), maxact=a.item()) + for i, a in zip(topi[u], topa[u])], + )) + rankings.append(dict(name="unit", score=list([ + u for u in range(len(topa))]))) + # TODO: consider including stats and ranking based on quantiles, + # variance, connectedness here. + + # if we have labeldata, then every unit also gets a bunch of other info + if labeldata is not None: + lscore, qscore, cc, ic = [dat[layer] + for dat in [iou_scores, iqr_scores, ccs, ics]] + if iqrdata is not None: + # If we have IQR thresholds, assign labels based on that + max_iqr, max_iqr_level = iqrdata[:2] + best_label = max_iqr[layer].max(0)[1] + best_score = lscore[best_label, torch.arange(lscore.shape[1])] + best_qscore = qscore[best_label, torch.arange(lscore.shape[1])] + else: + # Otherwise, assign labels based on max iou + best_score, best_label = lscore.max(0) + best_qscore = qscore[best_label, torch.arange(qscore.shape[1])] + record['iou_threshold'] = iou_threshold, + for u, urec in enumerate(units): + score, qscore, label = ( + best_score[u], best_qscore[u], best_label[u]) + urec.update(dict( + iou=score.item(), + iou_iqr=qscore.item(), + lc=lcs[label].item(), + cc=cc[catnumber[labelnames[label][1]], u].item(), + ic=ic[label, u].item(), + interp=(qscore.item() > iqr_threshold and + score.item() > iou_threshold), + iou_labelnum=label.item(), + iou_label=labelnames[label.item()][0], + iou_cat=labelnames[label.item()][1], + )) + if maxioudata is not None: + max_iou, max_iou_level, max_iou_quantile = maxioudata + qualified_iou = max_iou[layer].clone() + # qualified_iou[max_iou_quantile[layer] > 0.75] = 0 + best_score, best_label = qualified_iou.max(0) + for u, urec in enumerate(units): + urec.update(dict( + maxiou=best_score[u].item(), + maxiou_label=labelnames[best_label[u].item()][0], + maxiou_cat=labelnames[best_label[u].item()][1], + maxiou_level=max_iou_level[layer][best_label[u], u].item(), + maxiou_quantile=max_iou_quantile[layer][ + best_label[u], u].item())) + if iqrdata is not None: + [max_iqr, max_iqr_level, max_iqr_quantile, + max_iqr_iou, max_iqr_agreement] = iqrdata + qualified_iqr = max_iqr[layer].clone() + qualified_iqr[max_iqr_quantile[layer] > 0.5] = 0 + best_score, best_label = qualified_iqr.max(0) + for u, urec in enumerate(units): + urec.update(dict( + iqr=best_score[u].item(), + iqr_label=labelnames[best_label[u].item()][0], + iqr_cat=labelnames[best_label[u].item()][1], + iqr_level=max_iqr_level[layer][best_label[u], u].item(), + iqr_quantile=max_iqr_quantile[layer][ + best_label[u], u].item(), + iqr_iou=max_iqr_iou[layer][best_label[u], u].item() + )) + if covariancedata is not None: + score = covariancedata[layer].correlation() + best_score, best_label = score.max(1) + for u, urec in enumerate(units): + urec.update(dict( + cor=best_score[u].item(), + cor_label=labelnames[best_label[u].item()][0], + cor_cat=labelnames[best_label[u].item()][1] + )) + if mergedata is not None: + # Final step: if the user passed any data to merge into the + # units, merge them now. This can be used, for example, to + # indiate that a unit is not interpretable based on some + # outside analysis of unit statistics. + for lrec in mergedata.get('layers', []): + if lrec['layer'] == layer: + break + else: + lrec = None + for u, urec in enumerate(lrec.get('units', []) if lrec else []): + units[u].update(urec) + # After populating per-unit info, populate per-layer ranking info + if labeldata is not None: + # Collect all labeled units + labelunits = defaultdict(list) + all_labelunits = defaultdict(list) + for u, urec in enumerate(units): + if urec['interp']: + labelunits[urec['iou_labelnum']].append(u) + all_labelunits[urec['iou_labelnum']].append(u) + # Sort all units in order with most popular label first. + label_ordering = sorted(units, + # Sort by: + key=lambda r: (-1 if r['interp'] else 0, # interpretable + -len(labelunits[r['iou_labelnum']]), # label freq, score + -max([units[u]['iou'] + for u in labelunits[r['iou_labelnum']]], default=0), + r['iou_labelnum'], # label + -r['iou'])) # unit score + # Add label and iou ranking. + rankings.append(dict(name="label", score=(numpy.argsort(list( + ur['unit'] for ur in label_ordering))).tolist())) + rankings.append(dict(name="max iou", metric="iou", score=list( + -ur['iou'] for ur in units))) + # Add ranking for top labels + # for labelnum in [n for n in sorted( + # all_labelunits.keys(), key=lambda x: + # -len(all_labelunits[x])) if len(all_labelunits[n])]: + # label = labelnames[labelnum][0] + # rankings.append(dict(name="%s-iou" % label, + # concept=label, metric='iou', + # score=(-lscore[labelnum, :]).tolist())) + # Collate labels by category then frequency. + record['labels'] = [dict( + label=labelnames[label][0], + labelnum=label, + units=labelunits[label], + cat=labelnames[label][1]) + for label in (sorted(labelunits.keys(), + # Sort by: + key=lambda l: (catorder.get( # category + labelnames[l][1], 0), + -len(labelunits[l]), # label freq + -max([units[u]['iou'] for u in labelunits[l]], + default=0) # score + ))) if len(labelunits[label])] + # Total number of interpretable units. + record['interpretable'] = sum(len(group['units']) + for group in record['labels']) + # Make a bargraph of labels + os.makedirs(os.path.join(outdir, safe_dir_name(layer)), + exist_ok=True) + catgroups = OrderedDict() + for _, cat in sorted([(v, k) for k, v in catorder.items()]): + catgroups[cat] = [] + for rec in record['labels']: + if rec['cat'] not in catgroups: + catgroups[rec['cat']] = [] + catgroups[rec['cat']].append(rec['label']) + make_svg_bargraph( + [rec['label'] for rec in record['labels']], + [len(rec['units']) for rec in record['labels']], + [(cat, len(group)) for cat, group in catgroups.items()], + filename=os.path.join(outdir, safe_dir_name(layer), + 'bargraph.svg')) + # Only show the bargraph if it is non-empty. + if len(record['labels']): + record['bargraph'] = 'bargraph.svg' + if maxioudata is not None: + rankings.append(dict(name="max maxiou", metric="maxiou", score=list( + -ur['maxiou'] for ur in units))) + if iqrdata is not None: + rankings.append(dict(name="max iqr", metric="iqr", score=list( + -ur['iqr'] for ur in units))) + if covariancedata is not None: + rankings.append(dict(name="max cor", metric="cor", score=list( + -ur['cor'] for ur in units))) + + all_layers.append(record) + # Now add the same rankings to every layer... + all_labels = None + if rank_all_labels: + all_labels = [name for name, cat in labelnames] + if labeldata is not None: + # Count layers+quadrants with a given label, and sort by freq + counted_labels = defaultdict(int) + for label in [ + re.sub(r'-(?:t|b|l|r|tl|tr|bl|br)$', '', unitrec['iou_label']) + for record in all_layers for unitrec in record['units']]: + counted_labels[label] += 1 + if all_labels is None: + all_labels = [label for count, label in sorted((-v, k) + for k, v in counted_labels.items())] + for record in all_layers: + layer = record['layer'] + for label in all_labels: + labelnum = labelnumber[label] + record['rankings'].append(dict(name="%s-iou" % label, + concept=label, metric='iou', + score=(-iou_scores[layer][labelnum, :]).tolist())) + + if maxioudata is not None: + if all_labels is None: + counted_labels = defaultdict(int) + for label in [ + re.sub(r'-(?:t|b|l|r|tl|tr|bl|br)$', '', + unitrec['maxiou_label']) + for record in all_layers for unitrec in record['units']]: + counted_labels[label] += 1 + all_labels = [label for count, label in sorted((-v, k) + for k, v in counted_labels.items())] + qualified_iou = max_iou[layer].clone() + qualified_iou[max_iou_quantile[layer] > 0.5] = 0 + for record in all_layers: + layer = record['layer'] + for label in all_labels: + labelnum = labelnumber[label] + record['rankings'].append(dict(name="%s-maxiou" % label, + concept=label, metric='maxiou', + score=(-qualified_iou[labelnum, :]).tolist())) + + if iqrdata is not None: + if all_labels is None: + counted_labels = defaultdict(int) + for label in [ + re.sub(r'-(?:t|b|l|r|tl|tr|bl|br)$', '', + unitrec['iqr_label']) + for record in all_layers for unitrec in record['units']]: + counted_labels[label] += 1 + all_labels = [label for count, label in sorted((-v, k) + for k, v in counted_labels.items())] + # qualified_iqr[max_iqr_quantile[layer] > 0.5] = 0 + for record in all_layers: + layer = record['layer'] + qualified_iqr = max_iqr[layer].clone() + for label in all_labels: + labelnum = labelnumber[label] + record['rankings'].append(dict(name="%s-iqr" % label, + concept=label, metric='iqr', + score=(-qualified_iqr[labelnum, :]).tolist())) + + if covariancedata is not None: + if all_labels is None: + counted_labels = defaultdict(int) + for label in [ + re.sub(r'-(?:t|b|l|r|tl|tr|bl|br)$', '', + unitrec['cor_label']) + for record in all_layers for unitrec in record['units']]: + counted_labels[label] += 1 + all_labels = [label for count, label in sorted((-v, k) + for k, v in counted_labels.items())] + for record in all_layers: + layer = record['layer'] + score = covariancedata[layer].correlation() + for label in all_labels: + labelnum = labelnumber[label] + record['rankings'].append(dict(name="%s-cor" % label, + concept=label, metric='cor', + score=(-score[:, labelnum]).tolist())) + + for record in all_layers: + layer = record['layer'] + # Dump per-layer json inside per-layer directory + record['dirname'] = '.' + with open(os.path.join(outdir, safe_dir_name(layer), 'dissect.json'), + 'w') as jsonfile: + top_record['layers'] = [record] + json.dump(top_record, jsonfile, indent=1) + # Copy the per-layer html + shutil.copy(os.path.join(srcdir, 'dissect.html'), + os.path.join(outdir, safe_dir_name(layer), 'dissect.html')) + record['dirname'] = safe_dir_name(layer) + + # Dump all-layer json in parent directory + with open(os.path.join(outdir, 'dissect.json'), 'w') as jsonfile: + top_record['layers'] = all_layers + json.dump(top_record, jsonfile, indent=1) + # Copy the all-layer html + shutil.copy(os.path.join(srcdir, 'dissect.html'), + os.path.join(outdir, 'dissect.html')) + shutil.copy(os.path.join(srcdir, 'edit.html'), + os.path.join(outdir, 'edit.html')) + + +def generate_images(outdir, model, dataset, topk, levels, + segrunner, row_length=None, gap_pixels=5, + row_images=True, single_images=False, prefix='', + batch_size=100, num_workers=24): + ''' + Creates an image strip file for every unit of every retained layer + of the model, in the format [outdir]/[layername]/[unitnum]-top.jpg. + Assumes that the indexes of topk refer to the indexes of dataset. + Limits each strip to the top row_length images. + ''' + progress = default_progress() + needed_images = {} + if row_images is False: + row_length = 1 + # Pass 1: needed_images lists all images that are topk for some unit. + for layer in topk: + topresult = topk[layer].result()[1].cpu() + for unit, row in enumerate(topresult): + for rank, imgnum in enumerate(row[:row_length]): + imgnum = imgnum.item() + if imgnum not in needed_images: + needed_images[imgnum] = [] + needed_images[imgnum].append((layer, unit, rank)) + levels = {k: v.cpu().numpy() for k, v in levels.items()} + row_length = len(row[:row_length]) + needed_sample = FixedSubsetSampler(sorted(needed_images.keys())) + device = next(model.parameters()).device + segloader = torch.utils.data.DataLoader(dataset, + batch_size=batch_size, num_workers=num_workers, + pin_memory=(device.type == 'cuda'), + sampler=needed_sample) + vizgrid, maskgrid, origrid, seggrid = [{} for _ in range(4)] + # Pass 2: populate vizgrid with visualizations of top units. + pool = None + for i, batch in enumerate( + progress(segloader, desc='Making images')): + # Reverse transformation to get the image in byte form. + seg, _, byte_im, _ = segrunner.run_and_segment_batch(batch, model, + want_rgb=True) + torch_features = model.retained_features() + scale_offset = getattr(model, 'scale_offset', None) + if pool is None: + # Distribute the work across processes: create shared mmaps. + for layer, tf in torch_features.items(): + [vizgrid[layer], maskgrid[layer], origrid[layer], + seggrid[layer]] = [ + create_temp_mmap_grid((tf.shape[1], + byte_im.shape[1], row_length, + byte_im.shape[2] + gap_pixels, depth), + dtype='uint8', + fill=255) + for depth in [3, 4, 3, 3]] + # Pass those mmaps to worker processes. + pool = WorkerPool(worker=VisualizeImageWorker, + memmap_grid_info=[ + {layer: (g.filename, g.shape, g.dtype) + for layer, g in grid.items()} + for grid in [vizgrid, maskgrid, origrid, seggrid]]) + byte_im = byte_im.cpu().numpy() + numpy_seg = seg.cpu().numpy() + features = {} + for index in range(len(byte_im)): + imgnum = needed_sample.samples[index + i*segloader.batch_size] + for layer, unit, rank in needed_images[imgnum]: + if layer not in features: + features[layer] = torch_features[layer].cpu().numpy() + pool.add(layer, unit, rank, + byte_im[index], + features[layer][index, unit], + levels[layer][unit], + scale_offset[layer] if scale_offset else None, + numpy_seg[index]) + pool.join() + # Pass 3: save image strips as [outdir]/[layer]/[unitnum]-[top/orig].jpg + pool = WorkerPool(worker=SaveImageWorker) + for layer, vg in progress(vizgrid.items(), desc='Saving images'): + os.makedirs(os.path.join(outdir, safe_dir_name(layer), + prefix + 'image'), exist_ok=True) + if single_images: + os.makedirs(os.path.join(outdir, safe_dir_name(layer), + prefix + 's-image'), exist_ok=True) + og, sg, mg = origrid[layer], seggrid[layer], maskgrid[layer] + for unit in progress(range(len(vg)), desc='Units'): + for suffix, grid in [('top.jpg', vg), ('orig.jpg', og), + ('seg.png', sg), ('mask.png', mg)]: + strip = grid[unit].reshape( + (grid.shape[1], grid.shape[2] * grid.shape[3], + grid.shape[4])) + if row_images: + filename = os.path.join(outdir, safe_dir_name(layer), + prefix + 'image', '%d-%s' % (unit, suffix)) + pool.add(strip[:,:-gap_pixels,:].copy(), filename) + # Image.fromarray(strip[:,:-gap_pixels,:]).save(filename, + # optimize=True, quality=80) + if single_images: + single_filename = os.path.join(outdir, safe_dir_name(layer), + prefix + 's-image', '%d-%s' % (unit, suffix)) + pool.add(strip[:,:strip.shape[1] // row_length + - gap_pixels,:].copy(), single_filename) + # Image.fromarray(strip[:,:strip.shape[1] // row_length + # - gap_pixels,:]).save(single_filename, + # optimize=True, quality=80) + pool.join() + # Delete the shared memory map files + clear_global_shared_files([g.filename + for grid in [vizgrid, maskgrid, origrid, seggrid] + for g in grid.values()]) + +global_shared_files = {} +def create_temp_mmap_grid(shape, dtype, fill): + dtype = numpy.dtype(dtype) + filename = os.path.join(tempfile.mkdtemp(), 'temp-%s-%s.mmap' % + ('x'.join('%d' % s for s in shape), dtype.name)) + fid = open(filename, mode='w+b') + original = numpy.memmap(fid, dtype=dtype, mode='w+', shape=shape) + original.fid = fid + original[...] = fill + global_shared_files[filename] = original + return original + +def shared_temp_mmap_grid(filename, shape, dtype): + if filename not in global_shared_files: + global_shared_files[filename] = numpy.memmap( + filename, dtype=dtype, mode='r+', shape=shape) + return global_shared_files[filename] + +def clear_global_shared_files(filenames): + for fn in filenames: + if fn in global_shared_files: + del global_shared_files[fn] + try: + os.unlink(fn) + except OSError: + pass + +class VisualizeImageWorker(WorkerBase): + def setup(self, memmap_grid_info): + self.vizgrid, self.maskgrid, self.origrid, self.seggrid = [ + {layer: shared_temp_mmap_grid(*info) + for layer, info in grid.items()} + for grid in memmap_grid_info] + def work(self, layer, unit, rank, + byte_im, acts, level, scale_offset, seg): + self.origrid[layer][unit,:,rank,:byte_im.shape[0],:] = byte_im + [self.vizgrid[layer][unit,:,rank,:byte_im.shape[0],:], + self.maskgrid[layer][unit,:,rank,:byte_im.shape[0],:]] = ( + activation_visualization( + byte_im, + acts, + level, + scale_offset=scale_offset, + return_mask=True)) + self.seggrid[layer][unit,:,rank,:byte_im.shape[0],:] = ( + segment_visualization(seg, byte_im.shape[0:2])) + +class SaveImageWorker(WorkerBase): + def work(self, data, filename): + Image.fromarray(data).save(filename, optimize=True, quality=80) + +def score_tally_stats(label_category, tc, truth, cc, ic): + pred = cc[label_category] + total = tc[label_category][:, None] + truth = truth[:, None] + epsilon = 1e-20 # avoid division-by-zero + union = pred + truth - ic + iou = ic.double() / (union.double() + epsilon) + arr = torch.empty(size=(2, 2) + ic.shape, dtype=ic.dtype, device=ic.device) + arr[0, 0] = ic + arr[0, 1] = pred - ic + arr[1, 0] = truth - ic + arr[1, 1] = total - union + arr = arr.double() / total.double() + mi = mutual_information(arr) + je = joint_entropy(arr) + iqr = mi / je + iqr[torch.isnan(iqr)] = 0 # Zero out any 0/0 + return iou, iqr + +def collect_quantiles_and_topk(outdir, model, segloader, + segrunner, k=100, resolution=1024): + ''' + Collects (estimated) quantile information and (exact) sorted top-K lists + for every channel in the retained layers of the model. Returns + a map of quantiles (one RunningQuantile for each layer) along with + a map of topk (one RunningTopK for each layer). + ''' + device = next(model.parameters()).device + features = model.retained_features() + cached_quantiles = { + layer: load_quantile_if_present(os.path.join(outdir, + safe_dir_name(layer)), 'quantiles.npz', + device=torch.device('cpu')) + for layer in features } + cached_topks = { + layer: load_topk_if_present(os.path.join(outdir, + safe_dir_name(layer)), 'topk.npz', + device=torch.device('cpu')) + for layer in features } + if (all(value is not None for value in cached_quantiles.values()) and + all(value is not None for value in cached_topks.values())): + return cached_quantiles, cached_topks + + layer_batch_size = 8 + all_layers = list(features.keys()) + layer_batches = [all_layers[i:i+layer_batch_size] + for i in range(0, len(all_layers), layer_batch_size)] + + quantiles, topks = {}, {} + progress = default_progress() + for layer_batch in layer_batches: + for i, batch in enumerate(progress(segloader, desc='Quantiles')): + # We don't actually care about the model output. + model(batch[0].to(device)) + features = model.retained_features() + # We care about the retained values + for key in layer_batch: + value = features[key] + if topks.get(key, None) is None: + topks[key] = RunningTopK(k) + if quantiles.get(key, None) is None: + quantiles[key] = RunningQuantile(resolution=resolution) + topvalue = value + if len(value.shape) > 2: + topvalue, _ = value.view(*(value.shape[:2] + (-1,))).max(2) + # Put the channel index last. + value = value.permute( + (0,) + tuple(range(2, len(value.shape))) + (1,) + ).contiguous().view(-1, value.shape[1]) + quantiles[key].add(value) + topks[key].add(topvalue) + # Save GPU memory + for key in layer_batch: + quantiles[key].to_(torch.device('cpu')) + topks[key].to_(torch.device('cpu')) + for layer in quantiles: + save_state_dict(quantiles[layer], + os.path.join(outdir, safe_dir_name(layer), 'quantiles.npz')) + save_state_dict(topks[layer], + os.path.join(outdir, safe_dir_name(layer), 'topk.npz')) + return quantiles, topks + +def collect_bincounts(outdir, model, segloader, levels, segrunner): + ''' + Returns label_counts, category_activation_counts, and intersection_counts, + across the data set, counting the pixels of intersection between upsampled, + thresholded model featuremaps, with segmentation classes in the segloader. + + label_counts (independent of model): pixels across the data set that + are labeled with the given label. + category_activation_counts (one per layer): for each feature channel, + pixels across the dataset where the channel exceeds the level + threshold. There is one count per category: activations only + contribute to the categories for which any category labels are + present on the images. + intersection_counts (one per layer): for each feature channel and + label, pixels across the dataset where the channel exceeds + the level, and the labeled segmentation class is also present. + + This is a performance-sensitive function. Best performance is + achieved with a counting scheme which assumes a segloader with + batch_size 1. + ''' + # Load cached data if present + (iou_scores, iqr_scores, + total_counts, label_counts, category_activation_counts, + intersection_counts) = {}, {}, None, None, {}, {} + found_all = True + for layer in model.retained_features(): + filename = os.path.join(outdir, safe_dir_name(layer), 'bincounts.npz') + if os.path.isfile(filename): + data = numpy.load(filename) + iou_scores[layer] = torch.from_numpy(data['iou_scores']) + iqr_scores[layer] = torch.from_numpy(data['iqr_scores']) + total_counts = torch.from_numpy(data['total_counts']) + label_counts = torch.from_numpy(data['label_counts']) + category_activation_counts[layer] = torch.from_numpy( + data['category_activation_counts']) + intersection_counts[layer] = torch.from_numpy( + data['intersection_counts']) + else: + found_all = False + if found_all: + return (iou_scores, iqr_scores, + total_counts, label_counts, category_activation_counts, + intersection_counts) + + device = next(model.parameters()).device + labelcat, categories = segrunner.get_label_and_category_names() + label_category = [categories.index(c) if c in categories else 0 + for l, c in labelcat] + num_labels, num_categories = (len(n) for n in [labelcat, categories]) + + # One-hot vector of category for each label + labelcat = torch.zeros(num_labels, num_categories, + dtype=torch.long, device=device) + labelcat.scatter_(1, torch.from_numpy(numpy.array(label_category, + dtype='int64')).to(device)[:,None], 1) + # Running bincounts + # activation_counts = {} + assert segloader.batch_size == 1 # category_activation_counts needs this. + category_activation_counts = {} + intersection_counts = {} + label_counts = torch.zeros(num_labels, dtype=torch.long, device=device) + total_counts = torch.zeros(num_categories, dtype=torch.long, device=device) + progress = default_progress() + scale_offset_map = getattr(model, 'scale_offset', None) + upsample_grids = {} + # total_batch_categories = torch.zeros( + # labelcat.shape[1], dtype=torch.long, device=device) + for i, batch in enumerate(progress(segloader, desc='Bincounts')): + seg, batch_label_counts, _, imshape = segrunner.run_and_segment_batch( + batch, model, want_bincount=True, want_rgb=True) + bc = batch_label_counts.cpu() + batch_label_counts = batch_label_counts.to(device) + seg = seg.to(device) + features = model.retained_features() + # Accumulate bincounts and identify nonzeros + label_counts += batch_label_counts[0] + batch_labels = bc[0].nonzero()[:,0] + batch_categories = labelcat[batch_labels].max(0)[0] + total_counts += batch_categories * ( + seg.shape[0] * seg.shape[2] * seg.shape[3]) + for key, value in features.items(): + if key not in upsample_grids: + upsample_grids[key] = upsample_grid(value.shape[2:], + seg.shape[2:], imshape, + scale_offset=scale_offset_map.get(key, None) + if scale_offset_map is not None else None, + dtype=value.dtype, device=value.device) + upsampled = torch.nn.functional.grid_sample(value, + upsample_grids[key], padding_mode='border') + amask = (upsampled > levels[key][None,:,None,None].to( + upsampled.device)) + ac = amask.int().view(amask.shape[1], -1).sum(1) + # if key not in activation_counts: + # activation_counts[key] = ac + # else: + # activation_counts[key] += ac + # The fastest approach: sum over each label separately! + for label in batch_labels.tolist(): + if label == 0: + continue # ignore the background label + imask = amask * ((seg == label).max(dim=1, keepdim=True)[0]) + ic = imask.int().view(imask.shape[1], -1).sum(1) + if key not in intersection_counts: + intersection_counts[key] = torch.zeros(num_labels, + amask.shape[1], dtype=torch.long, device=device) + intersection_counts[key][label] += ic + # Count activations within images that have category labels. + # Note: This only makes sense with batch-size one + # total_batch_categories += batch_categories + cc = batch_categories[:,None] * ac[None,:] + if key not in category_activation_counts: + category_activation_counts[key] = cc + else: + category_activation_counts[key] += cc + iou_scores = {} + iqr_scores = {} + for k in intersection_counts: + iou_scores[k], iqr_scores[k] = score_tally_stats( + label_category, total_counts, label_counts, + category_activation_counts[k], intersection_counts[k]) + for k in intersection_counts: + numpy.savez(os.path.join(outdir, safe_dir_name(k), 'bincounts.npz'), + iou_scores=iou_scores[k].cpu().numpy(), + iqr_scores=iqr_scores[k].cpu().numpy(), + total_counts=total_counts.cpu().numpy(), + label_counts=label_counts.cpu().numpy(), + category_activation_counts=category_activation_counts[k] + .cpu().numpy(), + intersection_counts=intersection_counts[k].cpu().numpy(), + levels=levels[k].cpu().numpy()) + return (iou_scores, iqr_scores, + total_counts, label_counts, category_activation_counts, + intersection_counts) + +def collect_cond_quantiles(outdir, model, segloader, segrunner): + ''' + Returns maxiou and maxiou_level across the data set, one per layer. + + This is a performance-sensitive function. Best performance is + achieved with a counting scheme which assumes a segloader with + batch_size 1. + ''' + device = next(model.parameters()).device + cached_cond_quantiles = { + layer: load_conditional_quantile_if_present(os.path.join(outdir, + safe_dir_name(layer)), 'cond_quantiles.npz') # on cpu + for layer in model.retained_features() } + label_fracs = load_npy_if_present(outdir, 'label_fracs.npy', 'cpu') + if label_fracs is not None and all( + value is not None for value in cached_cond_quantiles.values()): + return cached_cond_quantiles, label_fracs + + labelcat, categories = segrunner.get_label_and_category_names() + label_category = [categories.index(c) if c in categories else 0 + for l, c in labelcat] + num_labels, num_categories = (len(n) for n in [labelcat, categories]) + + # One-hot vector of category for each label + labelcat = torch.zeros(num_labels, num_categories, + dtype=torch.long, device=device) + labelcat.scatter_(1, torch.from_numpy(numpy.array(label_category, + dtype='int64')).to(device)[:,None], 1) + # Running maxiou + assert segloader.batch_size == 1 # category_activation_counts needs this. + conditional_quantiles = {} + label_counts = torch.zeros(num_labels, dtype=torch.long, device=device) + pixel_count = 0 + progress = default_progress() + scale_offset_map = getattr(model, 'scale_offset', None) + upsample_grids = {} + common_conditions = set() + if label_fracs is None or label_fracs is 0: + for i, batch in enumerate(progress(segloader, desc='label fracs')): + seg, batch_label_counts, im, _ = segrunner.run_and_segment_batch( + batch, model, want_bincount=True, want_rgb=True) + batch_label_counts = batch_label_counts.to(device) + features = model.retained_features() + # Accumulate bincounts and identify nonzeros + label_counts += batch_label_counts[0] + pixel_count += seg.shape[2] * seg.shape[3] + label_fracs = (label_counts.cpu().float() / pixel_count)[:, None, None] + numpy.save(os.path.join(outdir, 'label_fracs.npy'), label_fracs) + + skip_threshold = 1e-4 + skip_labels = set(i.item() + for i in (label_fracs.view(-1) < skip_threshold).nonzero().view(-1)) + + for layer in progress(model.retained_features().keys(), desc='CQ layers'): + if cached_cond_quantiles.get(layer, None) is not None: + conditional_quantiles[layer] = cached_cond_quantiles[layer] + continue + + for i, batch in enumerate(progress(segloader, desc='Condquant')): + seg, batch_label_counts, _, imshape = ( + segrunner.run_and_segment_batch( + batch, model, want_bincount=True, want_rgb=True)) + bc = batch_label_counts.cpu() + batch_label_counts = batch_label_counts.to(device) + features = model.retained_features() + # Accumulate bincounts and identify nonzeros + label_counts += batch_label_counts[0] + pixel_count += seg.shape[2] * seg.shape[3] + batch_labels = bc[0].nonzero()[:,0] + batch_categories = labelcat[batch_labels].max(0)[0] + cpu_seg = None + value = features[layer] + if layer not in upsample_grids: + upsample_grids[layer] = upsample_grid(value.shape[2:], + seg.shape[2:], imshape, + scale_offset=scale_offset_map.get(layer, None) + if scale_offset_map is not None else None, + dtype=value.dtype, device=value.device) + if layer not in conditional_quantiles: + conditional_quantiles[layer] = RunningConditionalQuantile( + resolution=2048) + upsampled = torch.nn.functional.grid_sample(value, + upsample_grids[layer], padding_mode='border').view( + value.shape[1], -1) + conditional_quantiles[layer].add(('all',), upsampled.t()) + cpu_upsampled = None + for label in batch_labels.tolist(): + if label in skip_labels: + continue + label_key = ('label', label) + if label_key in common_conditions: + imask = (seg == label).max(dim=1)[0].view(-1) + intersected = upsampled[:, imask] + conditional_quantiles[layer].add(('label', label), + intersected.t()) + else: + if cpu_seg is None: + cpu_seg = seg.cpu() + if cpu_upsampled is None: + cpu_upsampled = upsampled.cpu() + imask = (cpu_seg == label).max(dim=1)[0].view(-1) + intersected = cpu_upsampled[:, imask] + conditional_quantiles[layer].add(('label', label), + intersected.t()) + if num_categories > 1: + for cat in batch_categories.nonzero()[:,0]: + conditional_quantiles[layer].add(('cat', cat.item()), + upsampled.t()) + # Move the most common conditions to the GPU. + if i and not i & (i - 1): # if i is a power of 2: + cq = conditional_quantiles[layer] + common_conditions = set(cq.most_common_conditions(64)) + cq.to_('cpu', [k for k in cq.running_quantiles.keys() + if k not in common_conditions]) + # When a layer is done, get it off the GPU + conditional_quantiles[layer].to_('cpu') + + label_fracs = (label_counts.cpu().float() / pixel_count)[:, None, None] + + for cq in conditional_quantiles.values(): + cq.to_('cpu') + + for layer in conditional_quantiles: + save_state_dict(conditional_quantiles[layer], + os.path.join(outdir, safe_dir_name(layer), 'cond_quantiles.npz')) + numpy.save(os.path.join(outdir, 'label_fracs.npy'), label_fracs) + + return conditional_quantiles, label_fracs + + +def collect_maxiou(outdir, model, segloader, segrunner): + ''' + Returns maxiou and maxiou_level across the data set, one per layer. + + This is a performance-sensitive function. Best performance is + achieved with a counting scheme which assumes a segloader with + batch_size 1. + ''' + device = next(model.parameters()).device + conditional_quantiles, label_fracs = collect_cond_quantiles( + outdir, model, segloader, segrunner) + + labelcat, categories = segrunner.get_label_and_category_names() + label_category = [categories.index(c) if c in categories else 0 + for l, c in labelcat] + num_labels, num_categories = (len(n) for n in [labelcat, categories]) + + label_list = [('label', i) for i in range(num_labels)] + category_list = [('all',)] if num_categories <= 1 else ( + [('cat', i) for i in range(num_categories)]) + max_iou, max_iou_level, max_iou_quantile = {}, {}, {} + fracs = torch.logspace(-3, 0, 100) + progress = default_progress() + for layer, cq in progress(conditional_quantiles.items(), desc='Maxiou'): + levels = cq.conditional(('all',)).quantiles(1 - fracs) + denoms = 1 - cq.collected_normalize(category_list, levels) + isects = (1 - cq.collected_normalize(label_list, levels)) * label_fracs + unions = label_fracs + denoms[label_category, :, :] - isects + iou = isects / unions + # TODO: erase any for which threshold is bad + max_iou[layer], level_bucket = iou.max(2) + max_iou_level[layer] = levels[ + torch.arange(levels.shape[0])[None,:], level_bucket] + max_iou_quantile[layer] = fracs[level_bucket] + for layer in model.retained_features(): + numpy.savez(os.path.join(outdir, safe_dir_name(layer), 'max_iou.npz'), + max_iou=max_iou[layer].cpu().numpy(), + max_iou_level=max_iou_level[layer].cpu().numpy(), + max_iou_quantile=max_iou_quantile[layer].cpu().numpy()) + return (max_iou, max_iou_level, max_iou_quantile) + +def collect_iqr(outdir, model, segloader, segrunner): + ''' + Returns iqr and iqr_level. + + This is a performance-sensitive function. Best performance is + achieved with a counting scheme which assumes a segloader with + batch_size 1. + ''' + max_iqr, max_iqr_level, max_iqr_quantile, max_iqr_iou = {}, {}, {}, {} + max_iqr_agreement = {} + found_all = True + for layer in model.retained_features(): + filename = os.path.join(outdir, safe_dir_name(layer), 'iqr.npz') + if os.path.isfile(filename): + data = numpy.load(filename) + max_iqr[layer] = torch.from_numpy(data['max_iqr']) + max_iqr_level[layer] = torch.from_numpy(data['max_iqr_level']) + max_iqr_quantile[layer] = torch.from_numpy(data['max_iqr_quantile']) + max_iqr_iou[layer] = torch.from_numpy(data['max_iqr_iou']) + max_iqr_agreement[layer] = torch.from_numpy( + data['max_iqr_agreement']) + else: + found_all = False + if found_all: + return (max_iqr, max_iqr_level, max_iqr_quantile, max_iqr_iou, + max_iqr_agreement) + + + device = next(model.parameters()).device + conditional_quantiles, label_fracs = collect_cond_quantiles( + outdir, model, segloader, segrunner) + + labelcat, categories = segrunner.get_label_and_category_names() + label_category = [categories.index(c) if c in categories else 0 + for l, c in labelcat] + num_labels, num_categories = (len(n) for n in [labelcat, categories]) + + label_list = [('label', i) for i in range(num_labels)] + category_list = [('all',)] if num_categories <= 1 else ( + [('cat', i) for i in range(num_categories)]) + full_mi, full_je, full_iqr = {}, {}, {} + fracs = torch.logspace(-3, 0, 100) + progress = default_progress() + for layer, cq in progress(conditional_quantiles.items(), desc='IQR'): + levels = cq.conditional(('all',)).quantiles(1 - fracs) + truth = label_fracs.to(device) + preds = (1 - cq.collected_normalize(category_list, levels) + )[label_category, :, :].to(device) + cond_isects = 1 - cq.collected_normalize(label_list, levels).to(device) + isects = cond_isects * truth + unions = truth + preds - isects + arr = torch.empty(size=(2, 2) + isects.shape, dtype=isects.dtype, + device=device) + arr[0, 0] = isects + arr[0, 1] = preds - isects + arr[1, 0] = truth - isects + arr[1, 1] = 1 - unions + arr.clamp_(0, 1) + mi = mutual_information(arr) + mi[:,:,-1] = 0 # at the 1.0 quantile should be no MI. + # Don't trust mi when less than label_frac is less than 1e-3, + # because our samples are too small. + mi[label_fracs.view(-1) < 1e-3, :, :] = 0 + je = joint_entropy(arr) + iqr = mi / je + iqr[torch.isnan(iqr)] = 0 # Zero out any 0/0 + full_mi[layer] = mi.cpu() + full_je[layer] = je.cpu() + full_iqr[layer] = iqr.cpu() + del mi, je + agreement = isects + arr[1, 1] + # When optimizing, maximize only over those pairs where the + # unit is positively correlated with the label, and where the + # threshold level is positive + positive_iqr = iqr + positive_iqr[agreement <= 0.8] = 0 + positive_iqr[(levels <= 0.0)[None, :, :].expand(positive_iqr.shape)] = 0 + # TODO: erase any for which threshold is bad + maxiqr, level_bucket = positive_iqr.max(2) + max_iqr[layer] = maxiqr.cpu() + max_iqr_level[layer] = levels.to(device)[ + torch.arange(levels.shape[0])[None,:], level_bucket].cpu() + max_iqr_quantile[layer] = fracs.to(device)[level_bucket].cpu() + max_iqr_agreement[layer] = agreement[ + torch.arange(agreement.shape[0])[:, None], + torch.arange(agreement.shape[1])[None, :], + level_bucket].cpu() + + # Compute the iou that goes with each maximized iqr + matching_iou = (isects[ + torch.arange(isects.shape[0])[:, None], + torch.arange(isects.shape[1])[None, :], + level_bucket] / + unions[ + torch.arange(unions.shape[0])[:, None], + torch.arange(unions.shape[1])[None, :], + level_bucket]) + matching_iou[torch.isnan(matching_iou)] = 0 + max_iqr_iou[layer] = matching_iou.cpu() + for layer in model.retained_features(): + numpy.savez(os.path.join(outdir, safe_dir_name(layer), 'iqr.npz'), + max_iqr=max_iqr[layer].cpu().numpy(), + max_iqr_level=max_iqr_level[layer].cpu().numpy(), + max_iqr_quantile=max_iqr_quantile[layer].cpu().numpy(), + max_iqr_iou=max_iqr_iou[layer].cpu().numpy(), + max_iqr_agreement=max_iqr_agreement[layer].cpu().numpy(), + full_mi=full_mi[layer].cpu().numpy(), + full_je=full_je[layer].cpu().numpy(), + full_iqr=full_iqr[layer].cpu().numpy()) + return (max_iqr, max_iqr_level, max_iqr_quantile, max_iqr_iou, + max_iqr_agreement) + +def mutual_information(arr): + total = 0 + for j in range(arr.shape[0]): + for k in range(arr.shape[1]): + joint = arr[j,k] + ind = arr[j,:].sum(dim=0) * arr[:,k].sum(dim=0) + term = joint * (joint / ind).log() + term[torch.isnan(term)] = 0 + total += term + return total.clamp_(0) + +def joint_entropy(arr): + total = 0 + for j in range(arr.shape[0]): + for k in range(arr.shape[1]): + joint = arr[j,k] + term = joint * joint.log() + term[torch.isnan(term)] = 0 + total += term + return (-total).clamp_(0) + +def information_quality_ratio(arr): + iqr = mutual_information(arr) / joint_entropy(arr) + iqr[torch.isnan(iqr)] = 0 + return iqr + +def collect_covariance(outdir, model, segloader, segrunner): + ''' + Returns label_mean, label_variance, unit_mean, unit_variance, + and cross_covariance across the data set. + + label_mean, label_variance (independent of model): + treating the label as a one-hot, each label's mean and variance. + unit_mean, unit_variance (one per layer): for each feature channel, + the mean and variance of the activations in that channel. + cross_covariance (one per layer): the cross covariance between the + labels and the units in the layer. + ''' + device = next(model.parameters()).device + cached_covariance = { + layer: load_covariance_if_present(os.path.join(outdir, + safe_dir_name(layer)), 'covariance.npz', device=device) + for layer in model.retained_features() } + if all(value is not None for value in cached_covariance.values()): + return cached_covariance + labelcat, categories = segrunner.get_label_and_category_names() + label_category = [categories.index(c) if c in categories else 0 + for l, c in labelcat] + num_labels, num_categories = (len(n) for n in [labelcat, categories]) + + # Running covariance + cov = {} + progress = default_progress() + scale_offset_map = getattr(model, 'scale_offset', None) + upsample_grids = {} + for i, batch in enumerate(progress(segloader, desc='Covariance')): + seg, _, _, imshape = segrunner.run_and_segment_batch(batch, model, + want_rgb=True) + features = model.retained_features() + ohfeats = multilabel_onehot(seg, num_labels, ignore_index=0) + # Accumulate bincounts and identify nonzeros + for key, value in features.items(): + if key not in upsample_grids: + upsample_grids[key] = upsample_grid(value.shape[2:], + seg.shape[2:], imshape, + scale_offset=scale_offset_map.get(key, None) + if scale_offset_map is not None else None, + dtype=value.dtype, device=value.device) + upsampled = torch.nn.functional.grid_sample(value, + upsample_grids[key].expand( + (value.shape[0],) + upsample_grids[key].shape[1:]), + padding_mode='border') + if key not in cov: + cov[key] = RunningCrossCovariance() + cov[key].add(upsampled, ohfeats) + for layer in cov: + save_state_dict(cov[layer], + os.path.join(outdir, safe_dir_name(layer), 'covariance.npz')) + return cov + +def multilabel_onehot(labels, num_labels, dtype=None, ignore_index=None): + ''' + Converts a multilabel tensor into a onehot tensor. + + The input labels is a tensor of shape (samples, multilabels, y, x). + The output is a tensor of shape (samples, num_labels, y, x). + If ignore_index is specified, labels with that index are ignored. + Each x in labels should be 0 <= x < num_labels, or x == ignore_index. + ''' + assert ignore_index is None or ignore_index <= 0 + if dtype is None: + dtype = torch.float + device = labels.device + chans = num_labels + (-ignore_index if ignore_index else 0) + outshape = (labels.shape[0], chans) + labels.shape[2:] + result = torch.zeros(outshape, device=device, dtype=dtype) + if ignore_index and ignore_index < 0: + labels = labels + (-ignore_index) + result.scatter_(1, labels, 1) + if ignore_index and ignore_index < 0: + result = result[:, -ignore_index:] + elif ignore_index is not None: + result[:, ignore_index] = 0 + return result + +def load_npy_if_present(outdir, filename, device): + filepath = os.path.join(outdir, filename) + if os.path.isfile(filepath): + data = numpy.load(filepath) + return torch.from_numpy(data).to(device) + return 0 + +def load_npz_if_present(outdir, filename, varnames, device): + filepath = os.path.join(outdir, filename) + if os.path.isfile(filepath): + data = numpy.load(filepath) + numpy_result = [data[n] for n in varnames] + return tuple(torch.from_numpy(data).to(device) for data in numpy_result) + return None + +def load_quantile_if_present(outdir, filename, device): + filepath = os.path.join(outdir, filename) + if os.path.isfile(filepath): + data = numpy.load(filepath) + result = RunningQuantile(state=data) + result.to_(device) + return result + return None + +def load_conditional_quantile_if_present(outdir, filename): + filepath = os.path.join(outdir, filename) + if os.path.isfile(filepath): + data = numpy.load(filepath) + result = RunningConditionalQuantile(state=data) + return result + return None + +def load_topk_if_present(outdir, filename, device): + filepath = os.path.join(outdir, filename) + if os.path.isfile(filepath): + data = numpy.load(filepath) + result = RunningTopK(state=data) + result.to_(device) + return result + return None + +def load_covariance_if_present(outdir, filename, device): + filepath = os.path.join(outdir, filename) + if os.path.isfile(filepath): + data = numpy.load(filepath) + result = RunningCrossCovariance(state=data) + result.to_(device) + return result + return None + +def save_state_dict(obj, filepath): + dirname = os.path.dirname(filepath) + os.makedirs(dirname, exist_ok=True) + dic = obj.state_dict() + numpy.savez(filepath, **dic) + +def upsample_grid(data_shape, target_shape, input_shape=None, + scale_offset=None, dtype=torch.float, device=None): + '''Prepares a grid to use with grid_sample to upsample a batch of + features in data_shape to the target_shape. Can use scale_offset + and input_shape to center the grid in a nondefault way: scale_offset + maps feature pixels to input_shape pixels, and it is assumed that + the target_shape is a uniform downsampling of input_shape.''' + # Default is that nothing is resized. + if target_shape is None: + target_shape = data_shape + # Make a default scale_offset to fill the image if there isn't one + if scale_offset is None: + scale = tuple(float(ts) / ds + for ts, ds in zip(target_shape, data_shape)) + offset = tuple(0.5 * s - 0.5 for s in scale) + else: + scale, offset = (v for v in zip(*scale_offset)) + # Handle downsampling for different input vs target shape. + if input_shape is not None: + scale = tuple(s * (ts - 1) / (ns - 1) + for s, ns, ts in zip(scale, input_shape, target_shape)) + offset = tuple(o * (ts - 1) / (ns - 1) + for o, ns, ts in zip(offset, input_shape, target_shape)) + # Pytorch needs target coordinates in terms of source coordinates [-1..1] + ty, tx = (((torch.arange(ts, dtype=dtype, device=device) - o) + * (2 / (s * (ss - 1))) - 1) + for ts, ss, s, o, in zip(target_shape, data_shape, scale, offset)) + # Whoa, note that grid_sample reverses the order y, x -> x, y. + grid = torch.stack( + (tx[None,:].expand(target_shape), ty[:,None].expand(target_shape)),2 + )[None,:,:,:].expand((1, target_shape[0], target_shape[1], 2)) + return grid + +def safe_dir_name(filename): + keepcharacters = (' ','.','_','-') + return ''.join(c + for c in filename if c.isalnum() or c in keepcharacters).rstrip() + +bargraph_palette = [ + ('#4B4CBF', '#B6B6F2'), + ('#55B05B', '#B6F2BA'), + ('#50BDAC', '#A5E5DB'), + ('#81C679', '#C0FF9B'), + ('#F0883B', '#F2CFB6'), + ('#D4CF24', '#F2F1B6'), + ('#D92E2B', '#F2B6B6'), + ('#AB6BC6', '#CFAAFF'), +] + +def make_svg_bargraph(labels, heights, categories, + barheight=100, barwidth=12, show_labels=True, filename=None): + # if len(labels) == 0: + # return # Nothing to do + unitheight = float(barheight) / max(max(heights, default=1), 1) + textheight = barheight if show_labels else 0 + labelsize = float(barwidth) + gap = float(barwidth) / 4 + textsize = barwidth + gap + rollup = max(heights, default=1) + textmargin = float(labelsize) * 2 / 3 + leftmargin = 32 + rightmargin = 8 + svgwidth = len(heights) * (barwidth + gap) + 2 * leftmargin + rightmargin + svgheight = barheight + textheight + + # create an SVG XML element + svg = et.Element('svg', width=str(svgwidth), height=str(svgheight), + version='1.1', xmlns='http://www.w3.org/2000/svg') + + # Draw the bar graph + basey = svgheight - textheight + x = leftmargin + # Add units scale on left + if len(heights): + for h in [1, (max(heights) + 1) // 2, max(heights)]: + et.SubElement(svg, 'text', x='0', y='0', + style=('font-family:sans-serif;font-size:%dpx;' + + 'text-anchor:end;alignment-baseline:hanging;' + + 'transform:translate(%dpx, %dpx);') % + (textsize, x - gap, basey - h * unitheight)).text = str(h) + et.SubElement(svg, 'text', x='0', y='0', + style=('font-family:sans-serif;font-size:%dpx;' + + 'text-anchor:middle;' + + 'transform:translate(%dpx, %dpx) rotate(-90deg)') % + (textsize, x - gap - textsize, basey - h * unitheight / 2) + ).text = 'units' + # Draw big category background rectangles + for catindex, (cat, catcount) in enumerate(categories): + if not catcount: + continue + et.SubElement(svg, 'rect', x=str(x), y=str(basey - rollup * unitheight), + width=(str((barwidth + gap) * catcount - gap)), + height = str(rollup*unitheight), + fill=bargraph_palette[catindex % len(bargraph_palette)][1]) + x += (barwidth + gap) * catcount + # Draw small bars as well as 45degree text labels + x = leftmargin + catindex = -1 + catcount = 0 + for label, height in zip(labels, heights): + while not catcount and catindex <= len(categories): + catindex += 1 + catcount = categories[catindex][1] + color = bargraph_palette[catindex % len(bargraph_palette)][0] + et.SubElement(svg, 'rect', x=str(x), y=str(basey-(height * unitheight)), + width=str(barwidth), height=str(height * unitheight), + fill=color) + x += barwidth + if show_labels: + et.SubElement(svg, 'text', x='0', y='0', + style=('font-family:sans-serif;font-size:%dpx;text-anchor:end;'+ + 'transform:translate(%dpx, %dpx) rotate(-45deg);') % + (labelsize, x, basey + textmargin)).text = readable(label) + x += gap + catcount -= 1 + # Text labels for each category + x = leftmargin + for cat, catcount in categories: + if not catcount: + continue + et.SubElement(svg, 'text', x='0', y='0', + style=('font-family:sans-serif;font-size:%dpx;text-anchor:end;'+ + 'transform:translate(%dpx, %dpx) rotate(-90deg);') % + (textsize, x + (barwidth + gap) * catcount - gap, + basey - rollup * unitheight + gap)).text = '%d %s' % ( + catcount, readable(cat + ('s' if catcount != 1 else ''))) + x += (barwidth + gap) * catcount + # Output - this is the bare svg. + result = et.tostring(svg) + if filename: + f = open(filename, 'wb') + # When writing to a file a special header is needed. + f.write(''.join([ + '\n', + '\n'] + ).encode('utf-8')) + f.write(result) + f.close() + return result + +readable_replacements = [(re.compile(r[0]), r[1]) for r in [ + (r'-[sc]$', ''), + (r'_', ' '), + ]] + +def readable(label): + for pattern, subst in readable_replacements: + label= re.sub(pattern, subst, label) + return label + +def reverse_normalize_from_transform(transform): + ''' + Crawl around the transforms attached to a dataset looking for a + Normalize transform, and return it a corresponding ReverseNormalize, + or None if no normalization is found. + ''' + if isinstance(transform, torchvision.transforms.Normalize): + return ReverseNormalize(transform.mean, transform.std) + t = getattr(transform, 'transform', None) + if t is not None: + return reverse_normalize_from_transform(t) + transforms = getattr(transform, 'transforms', None) + if transforms is not None: + for t in reversed(transforms): + result = reverse_normalize_from_transform(t) + if result is not None: + return result + return None + +class ReverseNormalize: + ''' + Applies the reverse of torchvision.transforms.Normalize. + ''' + def __init__(self, mean, stdev): + mean = numpy.array(mean) + stdev = numpy.array(stdev) + self.mean = torch.from_numpy(mean)[None,:,None,None].float() + self.stdev = torch.from_numpy(stdev)[None,:,None,None].float() + def __call__(self, data): + device = data.device + return data.mul(self.stdev.to(device)).add_(self.mean.to(device)) + +class ImageOnlySegRunner: + def __init__(self, dataset, recover_image=None): + if recover_image is None: + recover_image = reverse_normalize_from_transform(dataset) + self.recover_image = recover_image + self.dataset = dataset + def get_label_and_category_names(self): + return [('-', '-')], ['-'] + def run_and_segment_batch(self, batch, model, + want_bincount=False, want_rgb=False): + [im] = batch + device = next(model.parameters()).device + if want_rgb: + rgb = self.recover_image(im.clone() + ).permute(0, 2, 3, 1).mul_(255).clamp(0, 255).byte() + else: + rgb = None + # Stubs for seg and bc + seg = torch.zeros(im.shape[0], 1, 1, 1, dtype=torch.long) + bc = torch.ones(im.shape[0], 1, dtype=torch.long) + # Run the model. + model(im.to(device)) + return seg, bc, rgb, im.shape[2:] + +class ClassifierSegRunner: + def __init__(self, dataset, recover_image=None): + # The dataset contains explicit segmentations + if recover_image is None: + recover_image = reverse_normalize_from_transform(dataset) + self.recover_image = recover_image + self.dataset = dataset + def get_label_and_category_names(self): + catnames = self.dataset.categories + label_and_cat_names = [(readable(label), + catnames[self.dataset.label_category[i]]) + for i, label in enumerate(self.dataset.labels)] + return label_and_cat_names, catnames + def run_and_segment_batch(self, batch, model, + want_bincount=False, want_rgb=False): + ''' + Runs the dissected model on one batch of the dataset, and + returns a multilabel semantic segmentation for the data. + Given a batch of size (n, c, y, x) the segmentation should + be a (long integer) tensor of size (n, d, y//r, x//r) where + d is the maximum number of simultaneous labels given to a pixel, + and where r is some (optional) resolution reduction factor. + In the segmentation returned, the label `0` is reserved for + the background "no-label". + + In addition to the segmentation, bc, rgb, and shape are returned + where bc is a per-image bincount counting returned label pixels, + rgb is a viewable (n, y, x, rgb) byte image tensor for the data + for visualizations (reversing normalizations, for example), and + shape is the (y, x) size of the data. If want_bincount or + want_rgb are False, those return values may be None. + ''' + im, seg, bc = batch + device = next(model.parameters()).device + if want_rgb: + rgb = self.recover_image(im.clone() + ).permute(0, 2, 3, 1).mul_(255).clamp(0, 255).byte() + else: + rgb = None + # Run the model. + model(im.to(device)) + return seg, bc, rgb, im.shape[2:] + +class GeneratorSegRunner: + def __init__(self, segmenter): + # The segmentations are given by an algorithm + if segmenter is None: + segmenter = UnifiedParsingSegmenter(segsizes=[256], segdiv='quad') + self.segmenter = segmenter + self.num_classes = len(segmenter.get_label_and_category_names()[0]) + def get_label_and_category_names(self): + return self.segmenter.get_label_and_category_names() + def run_and_segment_batch(self, batch, model, + want_bincount=False, want_rgb=False): + ''' + Runs the dissected model on one batch of the dataset, and + returns a multilabel semantic segmentation for the data. + Given a batch of size (n, c, y, x) the segmentation should + be a (long integer) tensor of size (n, d, y//r, x//r) where + d is the maximum number of simultaneous labels given to a pixel, + and where r is some (optional) resolution reduction factor. + In the segmentation returned, the label `0` is reserved for + the background "no-label". + + In addition to the segmentation, bc, rgb, and shape are returned + where bc is a per-image bincount counting returned label pixels, + rgb is a viewable (n, y, x, rgb) byte image tensor for the data + for visualizations (reversing normalizations, for example), and + shape is the (y, x) size of the data. If want_bincount or + want_rgb are False, those return values may be None. + ''' + device = next(model.parameters()).device + z_batch = batch[0] + tensor_images = model(z_batch.to(device)) + seg = self.segmenter.segment_batch(tensor_images, downsample=2) + if want_bincount: + index = torch.arange(z_batch.shape[0], + dtype=torch.long, device=device) + bc = (seg + index[:, None, None, None] * self.num_classes).view(-1 + ).bincount(minlength=z_batch.shape[0] * self.num_classes) + bc = bc.view(z_batch.shape[0], self.num_classes) + else: + bc = None + if want_rgb: + images = ((tensor_images + 1) / 2 * 255) + rgb = images.permute(0, 2, 3, 1).clamp(0, 255).byte() + else: + rgb = None + return seg, bc, rgb, tensor_images.shape[2:] diff --git a/netdissect/easydict.py b/netdissect/easydict.py new file mode 100644 index 0000000000000000000000000000000000000000..0188f524b87eef75c175772ff262b93b47919ba7 --- /dev/null +++ b/netdissect/easydict.py @@ -0,0 +1,126 @@ +''' +From https://github.com/makinacorpus/easydict. +''' + +class EasyDict(dict): + """ + Get attributes + + >>> d = EasyDict({'foo':3}) + >>> d['foo'] + 3 + >>> d.foo + 3 + >>> d.bar + Traceback (most recent call last): + ... + AttributeError: 'EasyDict' object has no attribute 'bar' + + Works recursively + + >>> d = EasyDict({'foo':3, 'bar':{'x':1, 'y':2}}) + >>> isinstance(d.bar, dict) + True + >>> d.bar.x + 1 + + Bullet-proof + + >>> EasyDict({}) + {} + >>> EasyDict(d={}) + {} + >>> EasyDict(None) + {} + >>> d = {'a': 1} + >>> EasyDict(**d) + {'a': 1} + + Set attributes + + >>> d = EasyDict() + >>> d.foo = 3 + >>> d.foo + 3 + >>> d.bar = {'prop': 'value'} + >>> d.bar.prop + 'value' + >>> d + {'foo': 3, 'bar': {'prop': 'value'}} + >>> d.bar.prop = 'newer' + >>> d.bar.prop + 'newer' + + + Values extraction + + >>> d = EasyDict({'foo':0, 'bar':[{'x':1, 'y':2}, {'x':3, 'y':4}]}) + >>> isinstance(d.bar, list) + True + >>> from operator import attrgetter + >>> map(attrgetter('x'), d.bar) + [1, 3] + >>> map(attrgetter('y'), d.bar) + [2, 4] + >>> d = EasyDict() + >>> d.keys() + [] + >>> d = EasyDict(foo=3, bar=dict(x=1, y=2)) + >>> d.foo + 3 + >>> d.bar.x + 1 + + Still like a dict though + + >>> o = EasyDict({'clean':True}) + >>> o.items() + [('clean', True)] + + And like a class + + >>> class Flower(EasyDict): + ... power = 1 + ... + >>> f = Flower() + >>> f.power + 1 + >>> f = Flower({'height': 12}) + >>> f.height + 12 + >>> f['power'] + 1 + >>> sorted(f.keys()) + ['height', 'power'] + """ + def __init__(self, d=None, **kwargs): + if d is None: + d = {} + if kwargs: + d.update(**kwargs) + for k, v in d.items(): + setattr(self, k, v) + # Class attributes + for k in self.__class__.__dict__.keys(): + if not (k.startswith('__') and k.endswith('__')): + setattr(self, k, getattr(self, k)) + + def __setattr__(self, name, value): + if isinstance(value, (list, tuple)): + value = [self.__class__(x) + if isinstance(x, dict) else x for x in value] + elif isinstance(value, dict) and not isinstance(value, self.__class__): + value = self.__class__(value) + super(EasyDict, self).__setattr__(name, value) + super(EasyDict, self).__setitem__(name, value) + + __setitem__ = __setattr__ + +def load_json(filename): + import json + with open(filename) as f: + return EasyDict(json.load(f)) + +if __name__ == "__main__": + import doctest + doctest.testmod() diff --git a/netdissect/edit.html b/netdissect/edit.html new file mode 100644 index 0000000000000000000000000000000000000000..9aac30bb08171c4c58eb936f9ba382e85a184803 --- /dev/null +++ b/netdissect/edit.html @@ -0,0 +1,805 @@ + + + + + + + + + + + + + +
+ + + + + + + + +
+
+

+ + +

+
+ + +
+ + +
+ +
+
+ +
+ +
+ +
{{urec.layer}} {{urec.unit}} +
+
+ +
+
+
+ +
+ +
+ +
+ + + + + +
+ +
+

Seeds to generate

+

+To transfer activations from one pixel to another (1) click on a source pixel +on the left image and (2) click on a target pixel on a right image, +then (3) choose a set of units to insert in the palette.

+
+
#{{ ex.id }}
+
+
+ +
+ +
+ +
+ + + + diff --git a/netdissect/evalablate.py b/netdissect/evalablate.py new file mode 100644 index 0000000000000000000000000000000000000000..2079ffdb303b288df77678109f701e40fdf5779b --- /dev/null +++ b/netdissect/evalablate.py @@ -0,0 +1,248 @@ +import torch, sys, os, argparse, textwrap, numbers, numpy, json, PIL +from torchvision import transforms +from torch.utils.data import TensorDataset +from netdissect.progress import default_progress, post_progress, desc_progress +from netdissect.progress import verbose_progress, print_progress +from netdissect.nethook import edit_layers +from netdissect.zdataset import standard_z_sample +from netdissect.autoeval import autoimport_eval +from netdissect.easydict import EasyDict +from netdissect.modelconfig import create_instrumented_model + +help_epilog = '''\ +Example: + +python -m netdissect.evalablate \ + --segmenter "netdissect.segmenter.UnifiedParsingSegmenter(segsizes=[256], segdiv='quad')" \ + --model "proggan.from_pth_file('models/lsun_models/${SCENE}_lsun.pth')" \ + --outdir dissect/dissectdir \ + --classes mirror coffeetable tree \ + --layers layer4 \ + --size 1000 + +Output layout: +dissectdir/layer5/ablation/mirror-iqr.json +{ class: "mirror", + classnum: 43, + pixel_total: 41342300, + class_pixels: 1234531, + layer: "layer5", + ranking: "mirror-iqr", + ablation_units: [341, 23, 12, 142, 83, ...] + ablation_pixels: [143242, 132344, 429931, ...] +} + +''' + +def main(): + # Training settings + def strpair(arg): + p = tuple(arg.split(':')) + if len(p) == 1: + p = p + p + return p + + parser = argparse.ArgumentParser(description='Ablation eval', + epilog=textwrap.dedent(help_epilog), + formatter_class=argparse.RawDescriptionHelpFormatter) + parser.add_argument('--model', type=str, default=None, + help='constructor for the model to test') + parser.add_argument('--pthfile', type=str, default=None, + help='filename of .pth file for the model') + parser.add_argument('--outdir', type=str, default='dissect', required=True, + help='directory for dissection output') + parser.add_argument('--layers', type=strpair, nargs='+', + help='space-separated list of layer names to edit' + + ', in the form layername[:reportedname]') + parser.add_argument('--classes', type=str, nargs='+', + help='space-separated list of class names to ablate') + parser.add_argument('--metric', type=str, default='iou', + help='ordering metric for selecting units') + parser.add_argument('--unitcount', type=int, default=30, + help='number of units to ablate') + parser.add_argument('--segmenter', type=str, + help='directory containing segmentation dataset') + parser.add_argument('--netname', type=str, default=None, + help='name for network in generated reports') + parser.add_argument('--batch_size', type=int, default=5, + help='batch size for forward pass') + parser.add_argument('--size', type=int, default=200, + help='number of images to test') + parser.add_argument('--no-cuda', action='store_true', default=False, + help='disables CUDA usage') + parser.add_argument('--quiet', action='store_true', default=False, + help='silences console output') + if len(sys.argv) == 1: + parser.print_usage(sys.stderr) + sys.exit(1) + args = parser.parse_args() + + # Set up console output + verbose_progress(not args.quiet) + + # Speed up pytorch + torch.backends.cudnn.benchmark = True + + # Set up CUDA + args.cuda = not args.no_cuda and torch.cuda.is_available() + if args.cuda: + torch.backends.cudnn.benchmark = True + + # Take defaults for model constructor etc from dissect.json settings. + with open(os.path.join(args.outdir, 'dissect.json')) as f: + dissection = EasyDict(json.load(f)) + if args.model is None: + args.model = dissection.settings.model + if args.pthfile is None: + args.pthfile = dissection.settings.pthfile + if args.segmenter is None: + args.segmenter = dissection.settings.segmenter + + # Instantiate generator + model = create_instrumented_model(args, gen=True, edit=True) + if model is None: + print('No model specified') + sys.exit(1) + + # Instantiate model + device = next(model.parameters()).device + input_shape = model.input_shape + + # 4d input if convolutional, 2d input if first layer is linear. + raw_sample = standard_z_sample(args.size, input_shape[1], seed=2).view( + (args.size,) + input_shape[1:]) + dataset = TensorDataset(raw_sample) + + # Create the segmenter + segmenter = autoimport_eval(args.segmenter) + + # Now do the actual work. + labelnames, catnames = ( + segmenter.get_label_and_category_names(dataset)) + label_category = [catnames.index(c) if c in catnames else 0 + for l, c in labelnames] + labelnum_from_name = {n[0]: i for i, n in enumerate(labelnames)} + + segloader = torch.utils.data.DataLoader(dataset, + batch_size=args.batch_size, num_workers=10, + pin_memory=(device.type == 'cuda')) + + # Index the dissection layers by layer name. + dissect_layer = {lrec.layer: lrec for lrec in dissection.layers} + + # First, collect a baseline + for l in model.ablation: + model.ablation[l] = None + + # For each sort-order, do an ablation + progress = default_progress() + for classname in progress(args.classes): + post_progress(c=classname) + for layername in progress(model.ablation): + post_progress(l=layername) + rankname = '%s-%s' % (classname, args.metric) + classnum = labelnum_from_name[classname] + try: + ranking = next(r for r in dissect_layer[layername].rankings + if r.name == rankname) + except: + print('%s not found' % rankname) + sys.exit(1) + ordering = numpy.argsort(ranking.score) + # Check if already done + ablationdir = os.path.join(args.outdir, layername, 'pixablation') + if os.path.isfile(os.path.join(ablationdir, '%s.json'%rankname)): + with open(os.path.join(ablationdir, '%s.json'%rankname)) as f: + data = EasyDict(json.load(f)) + # If the unit ordering is not the same, something is wrong + if not all(a == o + for a, o in zip(data.ablation_units, ordering)): + continue + if len(data.ablation_effects) >= args.unitcount: + continue # file already done. + measurements = data.ablation_effects + measurements = measure_ablation(segmenter, segloader, + model, classnum, layername, ordering[:args.unitcount]) + measurements = measurements.cpu().numpy().tolist() + os.makedirs(ablationdir, exist_ok=True) + with open(os.path.join(ablationdir, '%s.json'%rankname), 'w') as f: + json.dump(dict( + classname=classname, + classnum=classnum, + baseline=measurements[0], + layer=layername, + metric=args.metric, + ablation_units=ordering.tolist(), + ablation_effects=measurements[1:]), f) + +def measure_ablation(segmenter, loader, model, classnum, layer, ordering): + total_bincount = 0 + data_size = 0 + device = next(model.parameters()).device + progress = default_progress() + for l in model.ablation: + model.ablation[l] = None + feature_units = model.feature_shape[layer][1] + feature_shape = model.feature_shape[layer][2:] + repeats = len(ordering) + total_scores = torch.zeros(repeats + 1) + for i, batch in enumerate(progress(loader)): + z_batch = batch[0] + model.ablation[layer] = None + tensor_images = model(z_batch.to(device)) + seg = segmenter.segment_batch(tensor_images, downsample=2) + mask = (seg == classnum).max(1)[0] + downsampled_seg = torch.nn.functional.adaptive_avg_pool2d( + mask.float()[:,None,:,:], feature_shape)[:,0,:,:] + total_scores[0] += downsampled_seg.sum().cpu() + # Now we need to do an intervention for every location + # that had a nonzero downsampled_seg, if any. + interventions_needed = downsampled_seg.nonzero() + location_count = len(interventions_needed) + if location_count == 0: + continue + interventions_needed = interventions_needed.repeat(repeats, 1) + inter_z = batch[0][interventions_needed[:,0]].to(device) + inter_chan = torch.zeros(repeats, location_count, feature_units, + device=device) + for j, u in enumerate(ordering): + inter_chan[j:, :, u] = 1 + inter_chan = inter_chan.view(len(inter_z), feature_units) + inter_loc = interventions_needed[:,1:] + scores = torch.zeros(len(inter_z)) + batch_size = len(batch[0]) + for j in range(0, len(inter_z), batch_size): + ibz = inter_z[j:j+batch_size] + ibl = inter_loc[j:j+batch_size].t() + imask = torch.zeros((len(ibz),) + feature_shape, device=ibz.device) + imask[(torch.arange(len(ibz)),) + tuple(ibl)] = 1 + ibc = inter_chan[j:j+batch_size] + model.ablation[layer] = ( + imask.float()[:,None,:,:] * ibc[:,:,None,None]) + tensor_images = model(ibz) + seg = segmenter.segment_batch(tensor_images, downsample=2) + mask = (seg == classnum).max(1)[0] + downsampled_iseg = torch.nn.functional.adaptive_avg_pool2d( + mask.float()[:,None,:,:], feature_shape)[:,0,:,:] + scores[j:j+batch_size] = downsampled_iseg[ + (torch.arange(len(ibz)),) + tuple(ibl)] + scores = scores.view(repeats, location_count).sum(1) + total_scores[1:] += scores + return total_scores + +def count_segments(segmenter, loader, model): + total_bincount = 0 + data_size = 0 + progress = default_progress() + for i, batch in enumerate(progress(loader)): + tensor_images = model(z_batch.to(device)) + seg = segmenter.segment_batch(tensor_images, downsample=2) + bc = (seg + index[:, None, None, None] * self.num_classes).view(-1 + ).bincount(minlength=z_batch.shape[0] * self.num_classes) + data_size += seg.shape[0] * seg.shape[2] * seg.shape[3] + total_bincount += batch_label_counts.float().sum(0) + normalized_bincount = total_bincount / data_size + return normalized_bincount + +if __name__ == '__main__': + main() diff --git a/netdissect/fullablate.py b/netdissect/fullablate.py new file mode 100644 index 0000000000000000000000000000000000000000..f92d2c514c0b92b3f33653c5b53198c9fd09cb80 --- /dev/null +++ b/netdissect/fullablate.py @@ -0,0 +1,235 @@ +import torch, sys, os, argparse, textwrap, numbers, numpy, json, PIL +from torchvision import transforms +from torch.utils.data import TensorDataset +from netdissect.progress import default_progress, post_progress, desc_progress +from netdissect.progress import verbose_progress, print_progress +from netdissect.nethook import edit_layers +from netdissect.zdataset import standard_z_sample +from netdissect.autoeval import autoimport_eval +from netdissect.easydict import EasyDict +from netdissect.modelconfig import create_instrumented_model + +help_epilog = '''\ +Example: + +python -m netdissect.evalablate \ + --segmenter "netdissect.GanImageSegmenter(segvocab='lowres', segsizes=[160,288], segdiv='quad')" \ + --model "proggan.from_pth_file('models/lsun_models/${SCENE}_lsun.pth')" \ + --outdir dissect/dissectdir \ + --classname tree \ + --layer layer4 \ + --size 1000 + +Output layout: +dissectdir/layer5/ablation/mirror-iqr.json +{ class: "mirror", + classnum: 43, + pixel_total: 41342300, + class_pixels: 1234531, + layer: "layer5", + ranking: "mirror-iqr", + ablation_units: [341, 23, 12, 142, 83, ...] + ablation_pixels: [143242, 132344, 429931, ...] +} + +''' + +def main(): + # Training settings + def strpair(arg): + p = tuple(arg.split(':')) + if len(p) == 1: + p = p + p + return p + + parser = argparse.ArgumentParser(description='Ablation eval', + epilog=textwrap.dedent(help_epilog), + formatter_class=argparse.RawDescriptionHelpFormatter) + parser.add_argument('--model', type=str, default=None, + help='constructor for the model to test') + parser.add_argument('--pthfile', type=str, default=None, + help='filename of .pth file for the model') + parser.add_argument('--outdir', type=str, default='dissect', required=True, + help='directory for dissection output') + parser.add_argument('--layer', type=strpair, + help='space-separated list of layer names to edit' + + ', in the form layername[:reportedname]') + parser.add_argument('--classname', type=str, + help='class name to ablate') + parser.add_argument('--metric', type=str, default='iou', + help='ordering metric for selecting units') + parser.add_argument('--unitcount', type=int, default=30, + help='number of units to ablate') + parser.add_argument('--segmenter', type=str, + help='directory containing segmentation dataset') + parser.add_argument('--netname', type=str, default=None, + help='name for network in generated reports') + parser.add_argument('--batch_size', type=int, default=25, + help='batch size for forward pass') + parser.add_argument('--mixed_units', action='store_true', default=False, + help='true to keep alpha for non-zeroed units') + parser.add_argument('--size', type=int, default=200, + help='number of images to test') + parser.add_argument('--no-cuda', action='store_true', default=False, + help='disables CUDA usage') + parser.add_argument('--quiet', action='store_true', default=False, + help='silences console output') + if len(sys.argv) == 1: + parser.print_usage(sys.stderr) + sys.exit(1) + args = parser.parse_args() + + # Set up console output + verbose_progress(not args.quiet) + + # Speed up pytorch + torch.backends.cudnn.benchmark = True + + # Set up CUDA + args.cuda = not args.no_cuda and torch.cuda.is_available() + if args.cuda: + torch.backends.cudnn.benchmark = True + + # Take defaults for model constructor etc from dissect.json settings. + with open(os.path.join(args.outdir, 'dissect.json')) as f: + dissection = EasyDict(json.load(f)) + if args.model is None: + args.model = dissection.settings.model + if args.pthfile is None: + args.pthfile = dissection.settings.pthfile + if args.segmenter is None: + args.segmenter = dissection.settings.segmenter + if args.layer is None: + args.layer = dissection.settings.layers[0] + args.layers = [args.layer] + + # Also load specific analysis + layername = args.layer[1] + if args.metric == 'iou': + summary = dissection + else: + with open(os.path.join(args.outdir, layername, args.metric, + args.classname, 'summary.json')) as f: + summary = EasyDict(json.load(f)) + + # Instantiate generator + model = create_instrumented_model(args, gen=True, edit=True) + if model is None: + print('No model specified') + sys.exit(1) + + # Instantiate model + device = next(model.parameters()).device + input_shape = model.input_shape + + # 4d input if convolutional, 2d input if first layer is linear. + raw_sample = standard_z_sample(args.size, input_shape[1], seed=3).view( + (args.size,) + input_shape[1:]) + dataset = TensorDataset(raw_sample) + + # Create the segmenter + segmenter = autoimport_eval(args.segmenter) + + # Now do the actual work. + labelnames, catnames = ( + segmenter.get_label_and_category_names(dataset)) + label_category = [catnames.index(c) if c in catnames else 0 + for l, c in labelnames] + labelnum_from_name = {n[0]: i for i, n in enumerate(labelnames)} + + segloader = torch.utils.data.DataLoader(dataset, + batch_size=args.batch_size, num_workers=10, + pin_memory=(device.type == 'cuda')) + + # Index the dissection layers by layer name. + + # First, collect a baseline + for l in model.ablation: + model.ablation[l] = None + + # For each sort-order, do an ablation + progress = default_progress() + classname = args.classname + classnum = labelnum_from_name[classname] + + # Get iou ranking from dissect.json + iou_rankname = '%s-%s' % (classname, 'iou') + dissect_layer = {lrec.layer: lrec for lrec in dissection.layers} + iou_ranking = next(r for r in dissect_layer[layername].rankings + if r.name == iou_rankname) + + # Get trained ranking from summary.json + rankname = '%s-%s' % (classname, args.metric) + summary_layer = {lrec.layer: lrec for lrec in summary.layers} + ranking = next(r for r in summary_layer[layername].rankings + if r.name == rankname) + + # Get ordering, first by ranking, then break ties by iou. + ordering = [t[2] for t in sorted([(s1, s2, i) + for i, (s1, s2) in enumerate(zip(ranking.score, iou_ranking.score))])] + values = (-numpy.array(ranking.score))[ordering] + if not args.mixed_units: + values[...] = 1 + + ablationdir = os.path.join(args.outdir, layername, 'fullablation') + measurements = measure_full_ablation(segmenter, segloader, + model, classnum, layername, + ordering[:args.unitcount], values[:args.unitcount]) + measurements = measurements.cpu().numpy().tolist() + os.makedirs(ablationdir, exist_ok=True) + with open(os.path.join(ablationdir, '%s.json'%rankname), 'w') as f: + json.dump(dict( + classname=classname, + classnum=classnum, + baseline=measurements[0], + layer=layername, + metric=args.metric, + ablation_units=ordering, + ablation_values=values.tolist(), + ablation_effects=measurements[1:]), f) + +def measure_full_ablation(segmenter, loader, model, classnum, layer, + ordering, values): + ''' + Quick and easy counting of segmented pixels reduced by ablating units. + ''' + progress = default_progress() + device = next(model.parameters()).device + feature_units = model.feature_shape[layer][1] + feature_shape = model.feature_shape[layer][2:] + repeats = len(ordering) + total_scores = torch.zeros(repeats + 1) + print(ordering) + print(values.tolist()) + with torch.no_grad(): + for l in model.ablation: + model.ablation[l] = None + for i, [ibz] in enumerate(progress(loader)): + ibz = ibz.cuda() + for num_units in progress(range(len(ordering) + 1)): + ablation = torch.zeros(feature_units, device=device) + ablation[ordering[:num_units]] = torch.tensor( + values[:num_units]).to(ablation.device, ablation.dtype) + model.ablation[layer] = ablation + tensor_images = model(ibz) + seg = segmenter.segment_batch(tensor_images, downsample=2) + mask = (seg == classnum).max(1)[0] + total_scores[num_units] += mask.sum().float().cpu() + return total_scores + +def count_segments(segmenter, loader, model): + total_bincount = 0 + data_size = 0 + progress = default_progress() + for i, batch in enumerate(progress(loader)): + tensor_images = model(z_batch.to(device)) + seg = segmenter.segment_batch(tensor_images, downsample=2) + bc = (seg + index[:, None, None, None] * self.num_classes).view(-1 + ).bincount(minlength=z_batch.shape[0] * self.num_classes) + data_size += seg.shape[0] * seg.shape[2] * seg.shape[3] + total_bincount += batch_label_counts.float().sum(0) + normalized_bincount = total_bincount / data_size + return normalized_bincount + +if __name__ == '__main__': + main() diff --git a/netdissect/modelconfig.py b/netdissect/modelconfig.py new file mode 100644 index 0000000000000000000000000000000000000000..d0ee37a809ea1bcbd803cd7d4e100e1bb93290c9 --- /dev/null +++ b/netdissect/modelconfig.py @@ -0,0 +1,144 @@ +''' +Original from https://github.com/CSAILVision/GANDissect +Modified by Erik Härkönen, 29.11.2019 +''' + +import numbers +import torch +from netdissect.autoeval import autoimport_eval +from netdissect.progress import print_progress +from netdissect.nethook import InstrumentedModel +from netdissect.easydict import EasyDict + +def create_instrumented_model(args, **kwargs): + ''' + Creates an instrumented model out of a namespace of arguments that + correspond to ArgumentParser command-line args: + model: a string to evaluate as a constructor for the model. + pthfile: (optional) filename of .pth file for the model. + layers: a list of layers to instrument, defaulted if not provided. + edit: True to instrument the layers for editing. + gen: True for a generator model. One-pixel input assumed. + imgsize: For non-generator models, (y, x) dimensions for RGB input. + cuda: True to use CUDA. + + The constructed model will be decorated with the following attributes: + input_shape: (usually 4d) tensor shape for single-image input. + output_shape: 4d tensor shape for output. + feature_shape: map of layer names to 4d tensor shape for featuremaps. + retained: map of layernames to tensors, filled after every evaluation. + ablation: if editing, map of layernames to [0..1] alpha values to fill. + replacement: if editing, map of layernames to values to fill. + + When editing, the feature value x will be replaced by: + `x = (replacement * ablation) + (x * (1 - ablation))` + ''' + + args = EasyDict(vars(args), **kwargs) + + # Construct the network + if args.model is None: + print_progress('No model specified') + return None + if isinstance(args.model, torch.nn.Module): + model = args.model + else: + model = autoimport_eval(args.model) + # Unwrap any DataParallel-wrapped model + if isinstance(model, torch.nn.DataParallel): + model = next(model.children()) + + # Load its state dict + meta = {} + if getattr(args, 'pthfile', None) is not None: + data = torch.load(args.pthfile) + if 'state_dict' in data: + meta = {} + for key in data: + if isinstance(data[key], numbers.Number): + meta[key] = data[key] + data = data['state_dict'] + submodule = getattr(args, 'submodule', None) + if submodule is not None and len(submodule): + remove_prefix = submodule + '.' + data = { k[len(remove_prefix):]: v for k, v in data.items() + if k.startswith(remove_prefix)} + if not len(data): + print_progress('No submodule %s found in %s' % + (submodule, args.pthfile)) + return None + model.load_state_dict(data, strict=not getattr(args, 'unstrict', False)) + + # Decide which layers to instrument. + if getattr(args, 'layer', None) is not None: + args.layers = [args.layer] + if getattr(args, 'layers', None) is None: + # Skip wrappers with only one named model + container = model + prefix = '' + while len(list(container.named_children())) == 1: + name, container = next(container.named_children()) + prefix += name + '.' + # Default to all nontrivial top-level layers except last. + args.layers = [prefix + name + for name, module in container.named_children() + if type(module).__module__ not in [ + # Skip ReLU and other activations. + 'torch.nn.modules.activation', + # Skip pooling layers. + 'torch.nn.modules.pooling'] + ][:-1] + print_progress('Defaulting to layers: %s' % ' '.join(args.layers)) + + # Now wrap the model for instrumentation. + model = InstrumentedModel(model) + model.meta = meta + + # Instrument the layers. + model.retain_layers(args.layers) + model.eval() + if args.cuda: + model.cuda() + + # Annotate input, output, and feature shapes + annotate_model_shapes(model, + gen=getattr(args, 'gen', False), + imgsize=getattr(args, 'imgsize', None), + latent_shape=getattr(args, 'latent_shape', None)) + return model + +def annotate_model_shapes(model, gen=False, imgsize=None, latent_shape=None): + assert (imgsize is not None) or gen + + # Figure the input shape. + if gen: + if latent_shape is None: + # We can guess a generator's input shape by looking at the model. + # Examine first conv in model to determine input feature size. + first_layer = [c for c in model.modules() + if isinstance(c, (torch.nn.Conv2d, torch.nn.ConvTranspose2d, + torch.nn.Linear))][0] + # 4d input if convolutional, 2d input if first layer is linear. + if isinstance(first_layer, (torch.nn.Conv2d, torch.nn.ConvTranspose2d)): + input_shape = (1, first_layer.in_channels, 1, 1) + else: + input_shape = (1, first_layer.in_features) + else: + # Specify input shape manually + input_shape = latent_shape + else: + # For a classifier, the input image shape is given as an argument. + input_shape = (1, 3) + tuple(imgsize) + + # Run the model once to observe feature shapes. + device = next(model.parameters()).device + dry_run = torch.zeros(input_shape).to(device) + with torch.no_grad(): + output = model(dry_run) + + # Annotate shapes. + model.input_shape = input_shape + model.feature_shape = { layer: feature.shape + for layer, feature in model.retained_features().items() } + model.output_shape = output.shape + return model diff --git a/netdissect/nethook.py b/netdissect/nethook.py new file mode 100644 index 0000000000000000000000000000000000000000..f36e84ee0cae2de2c3be247498408cf66db3ee8f --- /dev/null +++ b/netdissect/nethook.py @@ -0,0 +1,266 @@ +''' +Utilities for instrumenting a torch model. + +InstrumentedModel will wrap a pytorch model and allow hooking +arbitrary layers to monitor or modify their output directly. + +Modified by Erik Härkönen: +- 29.11.2019: Unhooking bugfix +- 25.01.2020: Offset edits, removed old API +''' + +import torch, numpy, types +from collections import OrderedDict + +class InstrumentedModel(torch.nn.Module): + ''' + A wrapper for hooking, probing and intervening in pytorch Modules. + Example usage: + + ``` + model = load_my_model() + with inst as InstrumentedModel(model): + inst.retain_layer(layername) + inst.edit_layer(layername, 0.5, target_features) + inst.edit_layer(layername, offset=offset_tensor) + inst(inputs) + original_features = inst.retained_layer(layername) + ``` + ''' + + def __init__(self, model): + super(InstrumentedModel, self).__init__() + self.model = model + self._retained = OrderedDict() + self._ablation = {} + self._replacement = {} + self._offset = {} + self._hooked_layer = {} + self._old_forward = {} + + def __enter__(self): + return self + + def __exit__(self, type, value, traceback): + self.close() + + def forward(self, *inputs, **kwargs): + return self.model(*inputs, **kwargs) + + def retain_layer(self, layername): + ''' + Pass a fully-qualified layer name (E.g., module.submodule.conv3) + to hook that layer and retain its output each time the model is run. + A pair (layername, aka) can be provided, and the aka will be used + as the key for the retained value instead of the layername. + ''' + self.retain_layers([layername]) + + def retain_layers(self, layernames): + ''' + Retains a list of a layers at once. + ''' + self.add_hooks(layernames) + for layername in layernames: + aka = layername + if not isinstance(aka, str): + layername, aka = layername + if aka not in self._retained: + self._retained[aka] = None + + def retained_features(self): + ''' + Returns a dict of all currently retained features. + ''' + return OrderedDict(self._retained) + + def retained_layer(self, aka=None, clear=False): + ''' + Retrieve retained data that was previously hooked by retain_layer. + Call this after the model is run. If clear is set, then the + retained value will return and also cleared. + ''' + if aka is None: + # Default to the first retained layer. + aka = next(self._retained.keys().__iter__()) + result = self._retained[aka] + if clear: + self._retained[aka] = None + return result + + def edit_layer(self, layername, ablation=None, replacement=None, offset=None): + ''' + Pass a fully-qualified layer name (E.g., module.submodule.conv3) + to hook that layer and modify its output each time the model is run. + The output of the layer will be modified to be a convex combination + of the replacement and x interpolated according to the ablation, i.e.: + `output = x * (1 - a) + (r * a)`. + Additionally or independently, an offset can be added to the output. + ''' + if not isinstance(layername, str): + layername, aka = layername + else: + aka = layername + + # The default ablation if a replacement is specified is 1.0. + if ablation is None and replacement is not None: + ablation = 1.0 + self.add_hooks([(layername, aka)]) + if ablation is not None: + self._ablation[aka] = ablation + if replacement is not None: + self._replacement[aka] = replacement + if offset is not None: + self._offset[aka] = offset + # If needed, could add an arbitrary postprocessing lambda here. + + def remove_edits(self, layername=None, remove_offset=True, remove_replacement=True): + ''' + Removes edits at the specified layer, or removes edits at all layers + if no layer name is specified. + ''' + if layername is None: + if remove_replacement: + self._ablation.clear() + self._replacement.clear() + if remove_offset: + self._offset.clear() + return + + if not isinstance(layername, str): + layername, aka = layername + else: + aka = layername + if remove_replacement and aka in self._ablation: + del self._ablation[aka] + if remove_replacement and aka in self._replacement: + del self._replacement[aka] + if remove_offset and aka in self._offset: + del self._offset[aka] + + def add_hooks(self, layernames): + ''' + Sets up a set of layers to be hooked. + + Usually not called directly: use edit_layer or retain_layer instead. + ''' + needed = set() + aka_map = {} + for name in layernames: + aka = name + if not isinstance(aka, str): + name, aka = name + if self._hooked_layer.get(aka, None) != name: + aka_map[name] = aka + needed.add(name) + if not needed: + return + for name, layer in self.model.named_modules(): + if name in aka_map: + needed.remove(name) + aka = aka_map[name] + self._hook_layer(layer, name, aka) + for name in needed: + raise ValueError('Layer %s not found in model' % name) + + def _hook_layer(self, layer, layername, aka): + ''' + Internal method to replace a forward method with a closure that + intercepts the call, and tracks the hook so that it can be reverted. + ''' + if aka in self._hooked_layer: + raise ValueError('Layer %s already hooked' % aka) + if layername in self._old_forward: + raise ValueError('Layer %s already hooked' % layername) + self._hooked_layer[aka] = layername + self._old_forward[layername] = (layer, aka, + layer.__dict__.get('forward', None)) + editor = self + original_forward = layer.forward + def new_forward(self, *inputs, **kwargs): + original_x = original_forward(*inputs, **kwargs) + x = editor._postprocess_forward(original_x, aka) + return x + layer.forward = types.MethodType(new_forward, layer) + + def _unhook_layer(self, aka): + ''' + Internal method to remove a hook, restoring the original forward method. + ''' + if aka not in self._hooked_layer: + return + layername = self._hooked_layer[aka] + layer, check, old_forward = self._old_forward[layername] + assert check == aka + if old_forward is None: + if 'forward' in layer.__dict__: + del layer.__dict__['forward'] + else: + layer.forward = old_forward + del self._old_forward[layername] + del self._hooked_layer[aka] + if aka in self._ablation: + del self._ablation[aka] + if aka in self._replacement: + del self._replacement[aka] + if aka in self._offset: + del self._offset[aka] + if aka in self._retained: + del self._retained[aka] + + def _postprocess_forward(self, x, aka): + ''' + The internal method called by the hooked layers after they are run. + ''' + # Retain output before edits, if desired. + if aka in self._retained: + self._retained[aka] = x.detach() + + # Apply replacement edit + a = make_matching_tensor(self._ablation, aka, x) + if a is not None: + x = x * (1 - a) + v = make_matching_tensor(self._replacement, aka, x) + if v is not None: + x += (v * a) + + # Apply offset edit + b = make_matching_tensor(self._offset, aka, x) + if b is not None: + x = x + b + + return x + + def close(self): + ''' + Unhooks all hooked layers in the model. + ''' + for aka in list(self._old_forward.keys()): + self._unhook_layer(aka) + assert len(self._old_forward) == 0 + + +def make_matching_tensor(valuedict, name, data): + ''' + Converts `valuedict[name]` to be a tensor with the same dtype, device, + and dimension count as `data`, and caches the converted tensor. + ''' + v = valuedict.get(name, None) + if v is None: + return None + if not isinstance(v, torch.Tensor): + # Accept non-torch data. + v = torch.from_numpy(numpy.array(v)) + valuedict[name] = v + if not v.device == data.device or not v.dtype == data.dtype: + # Ensure device and type matches. + assert not v.requires_grad, '%s wrong device or type' % (name) + v = v.to(device=data.device, dtype=data.dtype) + valuedict[name] = v + if len(v.shape) < len(data.shape): + # Ensure dimensions are unsqueezed as needed. + assert not v.requires_grad, '%s wrong dimensions' % (name) + v = v.view((1,) + tuple(v.shape) + + (1,) * (len(data.shape) - len(v.shape) - 1)) + valuedict[name] = v + return v diff --git a/netdissect/parallelfolder.py b/netdissect/parallelfolder.py new file mode 100644 index 0000000000000000000000000000000000000000..a741691569a7c85e96d3b3d9be12b40d508f0044 --- /dev/null +++ b/netdissect/parallelfolder.py @@ -0,0 +1,118 @@ +''' +Variants of pytorch's ImageFolder for loading image datasets with more +information, such as parallel feature channels in separate files, +cached files with lists of filenames, etc. +''' + +import os, torch, re +import torch.utils.data as data +from torchvision.datasets.folder import default_loader +from PIL import Image +from collections import OrderedDict +from .progress import default_progress + +def grayscale_loader(path): + with open(path, 'rb') as f: + return Image.open(f).convert('L') + +class ParallelImageFolders(data.Dataset): + """ + A data loader that looks for parallel image filenames, for example + + photo1/park/004234.jpg + photo1/park/004236.jpg + photo1/park/004237.jpg + + photo2/park/004234.png + photo2/park/004236.png + photo2/park/004237.png + """ + def __init__(self, image_roots, + transform=None, + loader=default_loader, + stacker=None, + intersection=False, + verbose=None, + size=None): + self.image_roots = image_roots + self.images = make_parallel_dataset(image_roots, + intersection=intersection, verbose=verbose) + if len(self.images) == 0: + raise RuntimeError("Found 0 images within: %s" % image_roots) + if size is not None: + self.image = self.images[:size] + if transform is not None and not hasattr(transform, '__iter__'): + transform = [transform for _ in image_roots] + self.transforms = transform + self.stacker = stacker + self.loader = loader + + def __getitem__(self, index): + paths = self.images[index] + sources = [self.loader(path) for path in paths] + # Add a common shared state dict to allow random crops/flips to be + # coordinated. + shared_state = {} + for s in sources: + s.shared_state = shared_state + if self.transforms is not None: + sources = [transform(source) + for source, transform in zip(sources, self.transforms)] + if self.stacker is not None: + sources = self.stacker(sources) + else: + sources = tuple(sources) + return sources + + def __len__(self): + return len(self.images) + +def is_npy_file(path): + return path.endswith('.npy') or path.endswith('.NPY') + +def is_image_file(path): + return None != re.search(r'\.(jpe?g|png)$', path, re.IGNORECASE) + +def walk_image_files(rootdir, verbose=None): + progress = default_progress(verbose) + indexfile = '%s.txt' % rootdir + if os.path.isfile(indexfile): + basedir = os.path.dirname(rootdir) + with open(indexfile) as f: + result = sorted([os.path.join(basedir, line.strip()) + for line in progress(f.readlines(), + desc='Reading %s' % os.path.basename(indexfile))]) + return result + result = [] + for dirname, _, fnames in sorted(progress(os.walk(rootdir), + desc='Walking %s' % os.path.basename(rootdir))): + for fname in sorted(fnames): + if is_image_file(fname) or is_npy_file(fname): + result.append(os.path.join(dirname, fname)) + return result + +def make_parallel_dataset(image_roots, intersection=False, verbose=None): + """ + Returns [(img1, img2), (img1, img2)..] + """ + image_roots = [os.path.expanduser(d) for d in image_roots] + image_sets = OrderedDict() + for j, root in enumerate(image_roots): + for path in walk_image_files(root, verbose=verbose): + key = os.path.splitext(os.path.relpath(path, root))[0] + if key not in image_sets: + image_sets[key] = [] + if not intersection and len(image_sets[key]) != j: + raise RuntimeError( + 'Images not parallel: %s missing from one dir' % (key)) + image_sets[key].append(path) + tuples = [] + for key, value in image_sets.items(): + if len(value) != len(image_roots): + if intersection: + continue + else: + raise RuntimeError( + 'Images not parallel: %s missing from one dir' % (key)) + tuples.append(tuple(value)) + return tuples diff --git a/netdissect/pidfile.py b/netdissect/pidfile.py new file mode 100644 index 0000000000000000000000000000000000000000..96a66814326bad444606ad829307fe225f4135e1 --- /dev/null +++ b/netdissect/pidfile.py @@ -0,0 +1,81 @@ +''' +Utility for simple distribution of work on multiple processes, by +making sure only one process is working on a job at once. +''' + +import os, errno, socket, atexit, time, sys + +def exit_if_job_done(directory): + if pidfile_taken(os.path.join(directory, 'lockfile.pid'), verbose=True): + sys.exit(0) + if os.path.isfile(os.path.join(directory, 'done.txt')): + with open(os.path.join(directory, 'done.txt')) as f: + msg = f.read() + print(msg) + sys.exit(0) + +def mark_job_done(directory): + with open(os.path.join(directory, 'done.txt'), 'w') as f: + f.write('Done by %d@%s %s at %s' % + (os.getpid(), socket.gethostname(), + os.getenv('STY', ''), + time.strftime('%c'))) + +def pidfile_taken(path, verbose=False): + ''' + Usage. To grab an exclusive lock for the remaining duration of the + current process (and exit if another process already has the lock), + do this: + + if pidfile_taken('job_423/lockfile.pid', verbose=True): + sys.exit(0) + + To do a batch of jobs, just run a script that does them all on + each available machine, sharing a network filesystem. When each + job grabs a lock, then this will automatically distribute the + jobs so that each one is done just once on one machine. + ''' + + # Try to create the file exclusively and write my pid into it. + try: + os.makedirs(os.path.dirname(path), exist_ok=True) + fd = os.open(path, os.O_CREAT | os.O_EXCL | os.O_RDWR) + except OSError as e: + if e.errno == errno.EEXIST: + # If we cannot because there was a race, yield the conflicter. + conflicter = 'race' + try: + with open(path, 'r') as lockfile: + conflicter = lockfile.read().strip() or 'empty' + except: + pass + if verbose: + print('%s held by %s' % (path, conflicter)) + return conflicter + else: + # Other problems get an exception. + raise + # Register to delete this file on exit. + lockfile = os.fdopen(fd, 'r+') + atexit.register(delete_pidfile, lockfile, path) + # Write my pid into the open file. + lockfile.write('%d@%s %s\n' % (os.getpid(), socket.gethostname(), + os.getenv('STY', ''))) + lockfile.flush() + os.fsync(lockfile) + # Return 'None' to say there was not a conflict. + return None + +def delete_pidfile(lockfile, path): + ''' + Runs at exit after pidfile_taken succeeds. + ''' + if lockfile is not None: + try: + lockfile.close() + except: + pass + try: + os.unlink(path) + except: + pass diff --git a/netdissect/plotutil.py b/netdissect/plotutil.py new file mode 100644 index 0000000000000000000000000000000000000000..187bcb9d5615c8ec51a43148b011c06b8ed6aff7 --- /dev/null +++ b/netdissect/plotutil.py @@ -0,0 +1,61 @@ +import matplotlib.pyplot as plt +import numpy + +def plot_tensor_images(data, **kwargs): + data = ((data + 1) / 2 * 255).permute(0, 2, 3, 1).byte().cpu().numpy() + width = int(numpy.ceil(numpy.sqrt(data.shape[0]))) + height = int(numpy.ceil(data.shape[0] / float(width))) + kwargs = dict(kwargs) + margin = 0.01 + if 'figsize' not in kwargs: + # Size figure to one display pixel per data pixel + dpi = plt.rcParams['figure.dpi'] + kwargs['figsize'] = ( + (1 + margin) * (width * data.shape[2] / dpi), + (1 + margin) * (height * data.shape[1] / dpi)) + f, axarr = plt.subplots(height, width, **kwargs) + if len(numpy.shape(axarr)) == 0: + axarr = numpy.array([[axarr]]) + if len(numpy.shape(axarr)) == 1: + axarr = axarr[None,:] + for i, im in enumerate(data): + ax = axarr[i // width, i % width] + ax.imshow(data[i]) + ax.axis('off') + for i in range(i, width * height): + ax = axarr[i // width, i % width] + ax.axis('off') + plt.subplots_adjust(wspace=margin, hspace=margin, + left=0, right=1, bottom=0, top=1) + plt.show() + +def plot_max_heatmap(data, shape=None, **kwargs): + if shape is None: + shape = data.shape[2:] + data = data.max(1)[0].cpu().numpy() + vmin = data.min() + vmax = data.max() + width = int(numpy.ceil(numpy.sqrt(data.shape[0]))) + height = int(numpy.ceil(data.shape[0] / float(width))) + kwargs = dict(kwargs) + margin = 0.01 + if 'figsize' not in kwargs: + # Size figure to one display pixel per data pixel + dpi = plt.rcParams['figure.dpi'] + kwargs['figsize'] = ( + width * shape[1] / dpi, height * shape[0] / dpi) + f, axarr = plt.subplots(height, width, **kwargs) + if len(numpy.shape(axarr)) == 0: + axarr = numpy.array([[axarr]]) + if len(numpy.shape(axarr)) == 1: + axarr = axarr[None,:] + for i, im in enumerate(data): + ax = axarr[i // width, i % width] + img = ax.imshow(data[i], vmin=vmin, vmax=vmax, cmap='hot') + ax.axis('off') + for i in range(i, width * height): + ax = axarr[i // width, i % width] + ax.axis('off') + plt.subplots_adjust(wspace=margin, hspace=margin, + left=0, right=1, bottom=0, top=1) + plt.show() diff --git a/netdissect/proggan.py b/netdissect/proggan.py new file mode 100644 index 0000000000000000000000000000000000000000..e37ae15f373ef6ad14279bb581042434c5563539 --- /dev/null +++ b/netdissect/proggan.py @@ -0,0 +1,299 @@ +import torch, numpy, itertools +import torch.nn as nn +from collections import OrderedDict + + +def print_network(net, verbose=False): + num_params = 0 + for param in net.parameters(): + num_params += param.numel() + if verbose: + print(net) + print('Total number of parameters: {:3.3f} M'.format(num_params / 1e6)) + + +def from_pth_file(filename): + ''' + Instantiate from a pth file. + ''' + state_dict = torch.load(filename) + if 'state_dict' in state_dict: + state_dict = state_dict['state_dict'] + # Convert old version of parameter names + if 'features.0.conv.weight' in state_dict: + state_dict = state_dict_from_old_pt_dict(state_dict) + sizes = sizes_from_state_dict(state_dict) + result = ProgressiveGenerator(sizes=sizes) + result.load_state_dict(state_dict) + return result + +############################################################################### +# Modules +############################################################################### + +class ProgressiveGenerator(nn.Sequential): + def __init__(self, resolution=None, sizes=None, modify_sequence=None, + output_tanh=False): + ''' + A pytorch progessive GAN generator that can be converted directly + from either a tensorflow model or a theano model. It consists of + a sequence of convolutional layers, organized in pairs, with an + upsampling and reduction of channels at every other layer; and + then finally followed by an output layer that reduces it to an + RGB [-1..1] image. + + The network can be given more layers to increase the output + resolution. The sizes argument indicates the fieature depth at + each upsampling, starting with the input z: [input-dim, 4x4-depth, + 8x8-depth, 16x16-depth...]. The output dimension is 2 * 2**len(sizes) + + Some default architectures can be selected by supplying the + resolution argument instead. + + The optional modify_sequence function can be used to transform the + sequence of layers before the network is constructed. + + If output_tanh is set to True, the network applies a tanh to clamp + the output to [-1,1] before output; otherwise the output is unclamped. + ''' + assert (resolution is None) != (sizes is None) + if sizes is None: + sizes = { + 8: [512, 512, 512], + 16: [512, 512, 512, 512], + 32: [512, 512, 512, 512, 256], + 64: [512, 512, 512, 512, 256, 128], + 128: [512, 512, 512, 512, 256, 128, 64], + 256: [512, 512, 512, 512, 256, 128, 64, 32], + 1024: [512, 512, 512, 512, 512, 256, 128, 64, 32, 16] + }[resolution] + # Follow the schedule of upsampling given by sizes. + # layers are called: layer1, layer2, etc; then output_128x128 + sequence = [] + def add_d(layer, name=None): + if name is None: + name = 'layer%d' % (len(sequence) + 1) + sequence.append((name, layer)) + add_d(NormConvBlock(sizes[0], sizes[1], kernel_size=4, padding=3)) + add_d(NormConvBlock(sizes[1], sizes[1], kernel_size=3, padding=1)) + for i, (si, so) in enumerate(zip(sizes[1:-1], sizes[2:])): + add_d(NormUpscaleConvBlock(si, so, kernel_size=3, padding=1)) + add_d(NormConvBlock(so, so, kernel_size=3, padding=1)) + # Create an output layer. During training, the progressive GAN + # learns several such output layers for various resolutions; we + # just include the last (highest resolution) one. + dim = 4 * (2 ** (len(sequence) // 2 - 1)) + add_d(OutputConvBlock(sizes[-1], tanh=output_tanh), + name='output_%dx%d' % (dim, dim)) + # Allow the sequence to be modified + if modify_sequence is not None: + sequence = modify_sequence(sequence) + super().__init__(OrderedDict(sequence)) + + def forward(self, x): + # Convert vector input to 1x1 featuremap. + x = x.view(x.shape[0], x.shape[1], 1, 1) + return super().forward(x) + +class PixelNormLayer(nn.Module): + def __init__(self): + super(PixelNormLayer, self).__init__() + + def forward(self, x): + return x / torch.sqrt(torch.mean(x**2, dim=1, keepdim=True) + 1e-8) + +class DoubleResolutionLayer(nn.Module): + def forward(self, x): + x = nn.functional.interpolate(x, scale_factor=2, mode='nearest') + return x + +class WScaleLayer(nn.Module): + def __init__(self, size, fan_in, gain=numpy.sqrt(2)): + super(WScaleLayer, self).__init__() + self.scale = gain / numpy.sqrt(fan_in) # No longer a parameter + self.b = nn.Parameter(torch.randn(size)) + self.size = size + + def forward(self, x): + x_size = x.size() + x = x * self.scale + self.b.view(1, -1, 1, 1).expand( + x_size[0], self.size, x_size[2], x_size[3]) + return x + +class NormConvBlock(nn.Module): + def __init__(self, in_channels, out_channels, kernel_size, padding): + super(NormConvBlock, self).__init__() + self.norm = PixelNormLayer() + self.conv = nn.Conv2d( + in_channels, out_channels, kernel_size, 1, padding, bias=False) + self.wscale = WScaleLayer(out_channels, in_channels, + gain=numpy.sqrt(2) / kernel_size) + self.relu = nn.LeakyReLU(inplace=True, negative_slope=0.2) + + def forward(self, x): + x = self.norm(x) + x = self.conv(x) + x = self.relu(self.wscale(x)) + return x + +class NormUpscaleConvBlock(nn.Module): + def __init__(self, in_channels, out_channels, kernel_size, padding): + super(NormUpscaleConvBlock, self).__init__() + self.norm = PixelNormLayer() + self.up = DoubleResolutionLayer() + self.conv = nn.Conv2d( + in_channels, out_channels, kernel_size, 1, padding, bias=False) + self.wscale = WScaleLayer(out_channels, in_channels, + gain=numpy.sqrt(2) / kernel_size) + self.relu = nn.LeakyReLU(inplace=True, negative_slope=0.2) + + def forward(self, x): + x = self.norm(x) + x = self.up(x) + x = self.conv(x) + x = self.relu(self.wscale(x)) + return x + +class OutputConvBlock(nn.Module): + def __init__(self, in_channels, tanh=False): + super().__init__() + self.norm = PixelNormLayer() + self.conv = nn.Conv2d( + in_channels, 3, kernel_size=1, padding=0, bias=False) + self.wscale = WScaleLayer(3, in_channels, gain=1) + self.clamp = nn.Hardtanh() if tanh else (lambda x: x) + + def forward(self, x): + x = self.norm(x) + x = self.conv(x) + x = self.wscale(x) + x = self.clamp(x) + return x + +############################################################################### +# Conversion +############################################################################### + +def from_tf_parameters(parameters): + ''' + Instantiate from tensorflow variables. + ''' + state_dict = state_dict_from_tf_parameters(parameters) + sizes = sizes_from_state_dict(state_dict) + result = ProgressiveGenerator(sizes=sizes) + result.load_state_dict(state_dict) + return result + +def from_old_pt_dict(parameters): + ''' + Instantiate from old pytorch state dict. + ''' + state_dict = state_dict_from_old_pt_dict(parameters) + sizes = sizes_from_state_dict(state_dict) + result = ProgressiveGenerator(sizes=sizes) + result.load_state_dict(state_dict) + return result + +def sizes_from_state_dict(params): + ''' + In a progressive GAN, the number of channels can change after each + upsampling. This function reads the state dict to figure the + number of upsamplings and the channel depth of each filter. + ''' + sizes = [] + for i in itertools.count(): + pt_layername = 'layer%d' % (i + 1) + try: + weight = params['%s.conv.weight' % pt_layername] + except KeyError: + break + if i == 0: + sizes.append(weight.shape[1]) + if i % 2 == 0: + sizes.append(weight.shape[0]) + return sizes + +def state_dict_from_tf_parameters(parameters): + ''' + Conversion from tensorflow parameters + ''' + def torch_from_tf(data): + return torch.from_numpy(data.eval()) + + params = dict(parameters) + result = {} + sizes = [] + for i in itertools.count(): + resolution = 4 * (2 ** (i // 2)) + # Translate parameter names. For example: + # 4x4/Dense/weight -> layer1.conv.weight + # 32x32/Conv0_up/weight -> layer7.conv.weight + # 32x32/Conv1/weight -> layer8.conv.weight + tf_layername = '%dx%d/%s' % (resolution, resolution, + 'Dense' if i == 0 else 'Conv' if i == 1 else + 'Conv0_up' if i % 2 == 0 else 'Conv1') + pt_layername = 'layer%d' % (i + 1) + # Stop looping when we run out of parameters. + try: + weight = torch_from_tf(params['%s/weight' % tf_layername]) + except KeyError: + break + # Transpose convolution weights into pytorch format. + if i == 0: + # Convert dense layer to 4x4 convolution + weight = weight.view(weight.shape[0], weight.shape[1] // 16, + 4, 4).permute(1, 0, 2, 3).flip(2, 3) + sizes.append(weight.shape[0]) + elif i % 2 == 0: + # Convert inverse convolution to convolution + weight = weight.permute(2, 3, 0, 1).flip(2, 3) + else: + # Ordinary Conv2d conversion. + weight = weight.permute(3, 2, 0, 1) + sizes.append(weight.shape[1]) + result['%s.conv.weight' % (pt_layername)] = weight + # Copy bias vector. + bias = torch_from_tf(params['%s/bias' % tf_layername]) + result['%s.wscale.b' % (pt_layername)] = bias + # Copy just finest-grained ToRGB output layers. For example: + # ToRGB_lod0/weight -> output.conv.weight + i -= 1 + resolution = 4 * (2 ** (i // 2)) + tf_layername = 'ToRGB_lod0' + pt_layername = 'output_%dx%d' % (resolution, resolution) + result['%s.conv.weight' % pt_layername] = torch_from_tf( + params['%s/weight' % tf_layername]).permute(3, 2, 0, 1) + result['%s.wscale.b' % pt_layername] = torch_from_tf( + params['%s/bias' % tf_layername]) + # Return parameters + return result + +def state_dict_from_old_pt_dict(params): + ''' + Conversion from the old pytorch model layer names. + ''' + result = {} + sizes = [] + for i in itertools.count(): + old_layername = 'features.%d' % i + pt_layername = 'layer%d' % (i + 1) + try: + weight = params['%s.conv.weight' % (old_layername)] + except KeyError: + break + if i == 0: + sizes.append(weight.shape[0]) + if i % 2 == 0: + sizes.append(weight.shape[1]) + result['%s.conv.weight' % (pt_layername)] = weight + result['%s.wscale.b' % (pt_layername)] = params[ + '%s.wscale.b' % (old_layername)] + # Copy the output layers. + i -= 1 + resolution = 4 * (2 ** (i // 2)) + pt_layername = 'output_%dx%d' % (resolution, resolution) + result['%s.conv.weight' % pt_layername] = params['output.conv.weight'] + result['%s.wscale.b' % pt_layername] = params['output.wscale.b'] + # Return parameters and also network architecture sizes. + return result + diff --git a/netdissect/progress.py b/netdissect/progress.py new file mode 100644 index 0000000000000000000000000000000000000000..702b24cf6668e6caad38d3c315eb658b6af4d230 --- /dev/null +++ b/netdissect/progress.py @@ -0,0 +1,98 @@ +''' +Utilities for showing progress bars, controlling default verbosity, etc. +''' + +# If the tqdm package is not available, then do not show progress bars; +# just connect print_progress to print. +try: + from tqdm import tqdm, tqdm_notebook +except: + tqdm = None + +default_verbosity = False + +def verbose_progress(verbose): + ''' + Sets default verbosity level. Set to True to see progress bars. + ''' + global default_verbosity + default_verbosity = verbose + +def tqdm_terminal(it, *args, **kwargs): + ''' + Some settings for tqdm that make it run better in resizable terminals. + ''' + return tqdm(it, *args, dynamic_ncols=True, ascii=True, + leave=(not nested_tqdm()), **kwargs) + +def in_notebook(): + ''' + True if running inside a Jupyter notebook. + ''' + # From https://stackoverflow.com/a/39662359/265298 + try: + shell = get_ipython().__class__.__name__ + if shell == 'ZMQInteractiveShell': + return True # Jupyter notebook or qtconsole + elif shell == 'TerminalInteractiveShell': + return False # Terminal running IPython + else: + return False # Other type (?) + except NameError: + return False # Probably standard Python interpreter + +def nested_tqdm(): + ''' + True if there is an active tqdm progress loop on the stack. + ''' + return hasattr(tqdm, '_instances') and len(tqdm._instances) > 0 + +def post_progress(**kwargs): + ''' + When within a progress loop, post_progress(k=str) will display + the given k=str status on the right-hand-side of the progress + status bar. If not within a visible progress bar, does nothing. + ''' + if nested_tqdm(): + innermost = max(tqdm._instances, key=lambda x: x.pos) + innermost.set_postfix(**kwargs) + +def desc_progress(desc): + ''' + When within a progress loop, desc_progress(str) changes the + left-hand-side description of the loop toe the given description. + ''' + if nested_tqdm(): + innermost = max(tqdm._instances, key=lambda x: x.pos) + innermost.set_description(desc) + +def print_progress(*args): + ''' + When within a progress loop, post_progress(k=str) will display + the given k=str status on the right-hand-side of the progress + status bar. If not within a visible progress bar, does nothing. + ''' + if default_verbosity: + printfn = print if tqdm is None else tqdm.write + printfn(' '.join(str(s) for s in args)) + +def default_progress(verbose=None, iftop=False): + ''' + Returns a progress function that can wrap iterators to print + progress messages, if verbose is True. + + If verbose is False or if iftop is True and there is already + a top-level tqdm loop being reported, then a quiet non-printing + identity function is returned. + + verbose can also be set to a spefific progress function rather + than True, and that function will be used. + ''' + global default_verbosity + if verbose is None: + verbose = default_verbosity + if not verbose or (iftop and nested_tqdm()) or tqdm is None: + return lambda x, *args, **kw: x + if verbose == True: + return tqdm_notebook if in_notebook() else tqdm_terminal + return verbose diff --git a/netdissect/runningstats.py b/netdissect/runningstats.py new file mode 100644 index 0000000000000000000000000000000000000000..fe4093e0318edeecf8aebc34771adbde5043e2d4 --- /dev/null +++ b/netdissect/runningstats.py @@ -0,0 +1,773 @@ +''' +Running statistics on the GPU using pytorch. + +RunningTopK maintains top-k statistics for a set of channels in parallel. +RunningQuantile maintains (sampled) quantile statistics for a set of channels. +''' + +import torch, math, numpy +from collections import defaultdict + +class RunningTopK: + ''' + A class to keep a running tally of the the top k values (and indexes) + of any number of torch feature components. Will work on the GPU if + the data is on the GPU. + + This version flattens all arrays to avoid crashes. + ''' + def __init__(self, k=100, state=None): + if state is not None: + self.set_state_dict(state) + return + self.k = k + self.count = 0 + # This version flattens all data internally to 2-d tensors, + # to avoid crashes with the current pytorch topk implementation. + # The data is puffed back out to arbitrary tensor shapes on ouput. + self.data_shape = None + self.top_data = None + self.top_index = None + self.next = 0 + self.linear_index = 0 + self.perm = None + + def add(self, data): + ''' + Adds a batch of data to be considered for the running top k. + The zeroth dimension enumerates the observations. All other + dimensions enumerate different features. + ''' + if self.top_data is None: + # Allocation: allocate a buffer of size 5*k, at least 10, for each. + self.data_shape = data.shape[1:] + feature_size = int(numpy.prod(self.data_shape)) + self.top_data = torch.zeros( + feature_size, max(10, self.k * 5), out=data.new()) + self.top_index = self.top_data.clone().long() + self.linear_index = 0 if len(data.shape) == 1 else torch.arange( + feature_size, out=self.top_index.new()).mul_( + self.top_data.shape[-1])[:,None] + size = data.shape[0] + sk = min(size, self.k) + if self.top_data.shape[-1] < self.next + sk: + # Compression: if full, keep topk only. + self.top_data[:,:self.k], self.top_index[:,:self.k] = ( + self.result(sorted=False, flat=True)) + self.next = self.k + free = self.top_data.shape[-1] - self.next + # Pick: copy the top sk of the next batch into the buffer. + # Currently strided topk is slow. So we clone after transpose. + # TODO: remove the clone() if it becomes faster. + cdata = data.contiguous().view(size, -1).t().clone() + td, ti = cdata.topk(sk, sorted=False) + self.top_data[:,self.next:self.next+sk] = td + self.top_index[:,self.next:self.next+sk] = (ti + self.count) + self.next += sk + self.count += size + + def result(self, sorted=True, flat=False): + ''' + Returns top k data items and indexes in each dimension, + with channels in the first dimension and k in the last dimension. + ''' + k = min(self.k, self.next) + # bti are top indexes relative to buffer array. + td, bti = self.top_data[:,:self.next].topk(k, sorted=sorted) + # we want to report top indexes globally, which is ti. + ti = self.top_index.view(-1)[ + (bti + self.linear_index).view(-1) + ].view(*bti.shape) + if flat: + return td, ti + else: + return (td.view(*(self.data_shape + (-1,))), + ti.view(*(self.data_shape + (-1,)))) + + def to_(self, device): + self.top_data = self.top_data.to(device) + self.top_index = self.top_index.to(device) + if isinstance(self.linear_index, torch.Tensor): + self.linear_index = self.linear_index.to(device) + + def state_dict(self): + return dict( + constructor=self.__module__ + '.' + + self.__class__.__name__ + '()', + k=self.k, + count=self.count, + data_shape=tuple(self.data_shape), + top_data=self.top_data.cpu().numpy(), + top_index=self.top_index.cpu().numpy(), + next=self.next, + linear_index=(self.linear_index.cpu().numpy() + if isinstance(self.linear_index, torch.Tensor) + else self.linear_index), + perm=self.perm) + + def set_state_dict(self, dic): + self.k = dic['k'].item() + self.count = dic['count'].item() + self.data_shape = tuple(dic['data_shape']) + self.top_data = torch.from_numpy(dic['top_data']) + self.top_index = torch.from_numpy(dic['top_index']) + self.next = dic['next'].item() + self.linear_index = (torch.from_numpy(dic['linear_index']) + if len(dic['linear_index'].shape) > 0 + else dic['linear_index'].item()) + +class RunningQuantile: + """ + Streaming randomized quantile computation for torch. + + Add any amount of data repeatedly via add(data). At any time, + quantile estimates (or old-style percentiles) can be read out using + quantiles(q) or percentiles(p). + + Accuracy scales according to resolution: the default is to + set resolution to be accurate to better than 0.1%, + while limiting storage to about 50,000 samples. + + Good for computing quantiles of huge data without using much memory. + Works well on arbitrary data with probability near 1. + + Based on the optimal KLL quantile algorithm by Karnin, Lang, and Liberty + from FOCS 2016. http://ieee-focs.org/FOCS-2016-Papers/3933a071.pdf + """ + + def __init__(self, resolution=6 * 1024, buffersize=None, seed=None, + state=None): + if state is not None: + self.set_state_dict(state) + return + self.depth = None + self.dtype = None + self.device = None + self.resolution = resolution + # Default buffersize: 128 samples (and smaller than resolution). + if buffersize is None: + buffersize = min(128, (resolution + 7) // 8) + self.buffersize = buffersize + self.samplerate = 1.0 + self.data = None + self.firstfree = [0] + self.randbits = torch.ByteTensor(resolution) + self.currentbit = len(self.randbits) - 1 + self.extremes = None + self.size = 0 + + def _lazy_init(self, incoming): + self.depth = incoming.shape[1] + self.dtype = incoming.dtype + self.device = incoming.device + self.data = [torch.zeros(self.depth, self.resolution, + dtype=self.dtype, device=self.device)] + self.extremes = torch.zeros(self.depth, 2, + dtype=self.dtype, device=self.device) + self.extremes[:,0] = float('inf') + self.extremes[:,-1] = -float('inf') + + def to_(self, device): + """Switches internal storage to specified device.""" + if device != self.device: + old_data = self.data + old_extremes = self.extremes + self.data = [d.to(device) for d in self.data] + self.extremes = self.extremes.to(device) + self.device = self.extremes.device + del old_data + del old_extremes + + def add(self, incoming): + if self.depth is None: + self._lazy_init(incoming) + assert len(incoming.shape) == 2 + assert incoming.shape[1] == self.depth, (incoming.shape[1], self.depth) + self.size += incoming.shape[0] + # Convert to a flat torch array. + if self.samplerate >= 1.0: + self._add_every(incoming) + return + # If we are sampling, then subsample a large chunk at a time. + self._scan_extremes(incoming) + chunksize = int(math.ceil(self.buffersize / self.samplerate)) + for index in range(0, len(incoming), chunksize): + batch = incoming[index:index+chunksize] + sample = sample_portion(batch, self.samplerate) + if len(sample): + self._add_every(sample) + + def _add_every(self, incoming): + supplied = len(incoming) + index = 0 + while index < supplied: + ff = self.firstfree[0] + available = self.data[0].shape[1] - ff + if available == 0: + if not self._shift(): + # If we shifted by subsampling, then subsample. + incoming = incoming[index:] + if self.samplerate >= 0.5: + # First time sampling - the data source is very large. + self._scan_extremes(incoming) + incoming = sample_portion(incoming, self.samplerate) + index = 0 + supplied = len(incoming) + ff = self.firstfree[0] + available = self.data[0].shape[1] - ff + copycount = min(available, supplied - index) + self.data[0][:,ff:ff + copycount] = torch.t( + incoming[index:index + copycount,:]) + self.firstfree[0] += copycount + index += copycount + + def _shift(self): + index = 0 + # If remaining space at the current layer is less than half prev + # buffer size (rounding up), then we need to shift it up to ensure + # enough space for future shifting. + while self.data[index].shape[1] - self.firstfree[index] < ( + -(-self.data[index-1].shape[1] // 2) if index else 1): + if index + 1 >= len(self.data): + return self._expand() + data = self.data[index][:,0:self.firstfree[index]] + data = data.sort()[0] + if index == 0 and self.samplerate >= 1.0: + self._update_extremes(data[:,0], data[:,-1]) + offset = self._randbit() + position = self.firstfree[index + 1] + subset = data[:,offset::2] + self.data[index + 1][:,position:position + subset.shape[1]] = subset + self.firstfree[index] = 0 + self.firstfree[index + 1] += subset.shape[1] + index += 1 + return True + + def _scan_extremes(self, incoming): + # When sampling, we need to scan every item still to get extremes + self._update_extremes( + torch.min(incoming, dim=0)[0], + torch.max(incoming, dim=0)[0]) + + def _update_extremes(self, minr, maxr): + self.extremes[:,0] = torch.min( + torch.stack([self.extremes[:,0], minr]), dim=0)[0] + self.extremes[:,-1] = torch.max( + torch.stack([self.extremes[:,-1], maxr]), dim=0)[0] + + def _randbit(self): + self.currentbit += 1 + if self.currentbit >= len(self.randbits): + self.randbits.random_(to=2) + self.currentbit = 0 + return self.randbits[self.currentbit] + + def state_dict(self): + return dict( + constructor=self.__module__ + '.' + + self.__class__.__name__ + '()', + resolution=self.resolution, + depth=self.depth, + buffersize=self.buffersize, + samplerate=self.samplerate, + data=[d.cpu().numpy()[:,:f].T + for d, f in zip(self.data, self.firstfree)], + sizes=[d.shape[1] for d in self.data], + extremes=self.extremes.cpu().numpy(), + size=self.size) + + def set_state_dict(self, dic): + self.resolution = int(dic['resolution']) + self.randbits = torch.ByteTensor(self.resolution) + self.currentbit = len(self.randbits) - 1 + self.depth = int(dic['depth']) + self.buffersize = int(dic['buffersize']) + self.samplerate = float(dic['samplerate']) + firstfree = [] + buffers = [] + for d, s in zip(dic['data'], dic['sizes']): + firstfree.append(d.shape[0]) + buf = numpy.zeros((d.shape[1], s), dtype=d.dtype) + buf[:,:d.shape[0]] = d.T + buffers.append(torch.from_numpy(buf)) + self.firstfree = firstfree + self.data = buffers + self.extremes = torch.from_numpy((dic['extremes'])) + self.size = int(dic['size']) + self.dtype = self.extremes.dtype + self.device = self.extremes.device + + def minmax(self): + if self.firstfree[0]: + self._scan_extremes(self.data[0][:,:self.firstfree[0]].t()) + return self.extremes.clone() + + def median(self): + return self.quantiles([0.5])[:,0] + + def mean(self): + return self.integrate(lambda x: x) / self.size + + def variance(self): + mean = self.mean()[:,None] + return self.integrate(lambda x: (x - mean).pow(2)) / (self.size - 1) + + def stdev(self): + return self.variance().sqrt() + + def _expand(self): + cap = self._next_capacity() + if cap > 0: + # First, make a new layer of the proper capacity. + self.data.insert(0, torch.zeros(self.depth, cap, + dtype=self.dtype, device=self.device)) + self.firstfree.insert(0, 0) + else: + # Unless we're so big we are just subsampling. + assert self.firstfree[0] == 0 + self.samplerate *= 0.5 + for index in range(1, len(self.data)): + # Scan for existing data that needs to be moved down a level. + amount = self.firstfree[index] + if amount == 0: + continue + position = self.firstfree[index-1] + # Move data down if it would leave enough empty space there + # This is the key invariant: enough empty space to fit half + # of the previous level's buffer size (rounding up) + if self.data[index-1].shape[1] - (amount + position) >= ( + -(-self.data[index-2].shape[1] // 2) if (index-1) else 1): + self.data[index-1][:,position:position + amount] = ( + self.data[index][:,:amount]) + self.firstfree[index-1] += amount + self.firstfree[index] = 0 + else: + # Scrunch the data if it would not. + data = self.data[index][:,:amount] + data = data.sort()[0] + if index == 1: + self._update_extremes(data[:,0], data[:,-1]) + offset = self._randbit() + scrunched = data[:,offset::2] + self.data[index][:,:scrunched.shape[1]] = scrunched + self.firstfree[index] = scrunched.shape[1] + return cap > 0 + + def _next_capacity(self): + cap = int(math.ceil(self.resolution * (0.67 ** len(self.data)))) + if cap < 2: + return 0 + # Round up to the nearest multiple of 8 for better GPU alignment. + cap = -8 * (-cap // 8) + return max(self.buffersize, cap) + + def _weighted_summary(self, sort=True): + if self.firstfree[0]: + self._scan_extremes(self.data[0][:,:self.firstfree[0]].t()) + size = sum(self.firstfree) + 2 + weights = torch.FloatTensor(size) # Floating point + summary = torch.zeros(self.depth, size, + dtype=self.dtype, device=self.device) + weights[0:2] = 0 + summary[:,0:2] = self.extremes + index = 2 + for level, ff in enumerate(self.firstfree): + if ff == 0: + continue + summary[:,index:index + ff] = self.data[level][:,:ff] + weights[index:index + ff] = 2.0 ** level + index += ff + assert index == summary.shape[1] + if sort: + summary, order = torch.sort(summary, dim=-1) + weights = weights[order.view(-1).cpu()].view(order.shape) + return (summary, weights) + + def quantiles(self, quantiles, old_style=False): + if self.size == 0: + return torch.full((self.depth, len(quantiles)), torch.nan) + summary, weights = self._weighted_summary() + cumweights = torch.cumsum(weights, dim=-1) - weights / 2 + if old_style: + # To be convenient with torch.percentile + cumweights -= cumweights[:,0:1].clone() + cumweights /= cumweights[:,-1:].clone() + else: + cumweights /= torch.sum(weights, dim=-1, keepdim=True) + result = torch.zeros(self.depth, len(quantiles), + dtype=self.dtype, device=self.device) + # numpy is needed for interpolation + if not hasattr(quantiles, 'cpu'): + quantiles = torch.Tensor(quantiles) + nq = quantiles.cpu().numpy() + ncw = cumweights.cpu().numpy() + nsm = summary.cpu().numpy() + for d in range(self.depth): + result[d] = torch.tensor(numpy.interp(nq, ncw[d], nsm[d]), + dtype=self.dtype, device=self.device) + return result + + def integrate(self, fun): + result = None + for level, ff in enumerate(self.firstfree): + if ff == 0: + continue + term = torch.sum( + fun(self.data[level][:,:ff]) * (2.0 ** level), + dim=-1) + if result is None: + result = term + else: + result += term + if result is not None: + result /= self.samplerate + return result + + def percentiles(self, percentiles): + return self.quantiles(percentiles, old_style=True) + + def readout(self, count=1001, old_style=True): + return self.quantiles( + torch.linspace(0.0, 1.0, count), old_style=old_style) + + def normalize(self, data): + ''' + Given input data as taken from the training distirbution, + normalizes every channel to reflect quantile values, + uniformly distributed, within [0, 1]. + ''' + assert self.size > 0 + assert data.shape[0] == self.depth + summary, weights = self._weighted_summary() + cumweights = torch.cumsum(weights, dim=-1) - weights / 2 + cumweights /= torch.sum(weights, dim=-1, keepdim=True) + result = torch.zeros_like(data).float() + # numpy is needed for interpolation + ndata = data.cpu().numpy().reshape((data.shape[0], -1)) + ncw = cumweights.cpu().numpy() + nsm = summary.cpu().numpy() + for d in range(self.depth): + normed = torch.tensor(numpy.interp(ndata[d], nsm[d], ncw[d]), + dtype=torch.float, device=data.device).clamp_(0.0, 1.0) + if len(data.shape) > 1: + normed = normed.view(*(data.shape[1:])) + result[d] = normed + return result + + +class RunningConditionalQuantile: + ''' + Equivalent to a map from conditions (any python hashable type) + to RunningQuantiles. The reason for the type is to allow limited + GPU memory to be exploited while counting quantile stats on many + different conditions, a few of which are common and which benefit + from GPU, but most of which are rare and would not all fit into + GPU RAM. + + To move a set of conditions to a device, use rcq.to_(device, conds). + Then in the future, move the tallied data to the device before + calling rcq.add, that is, rcq.add(cond, data.to(device)). + + To allow the caller to decide which conditions to allow to use GPU, + rcq.most_common_conditions(n) returns a list of the n most commonly + added conditions so far. + ''' + def __init__(self, resolution=6 * 1024, buffersize=None, seed=None, + state=None): + self.first_rq = None + self.call_stats = defaultdict(int) + self.running_quantiles = {} + if state is not None: + self.set_state_dict(state) + return + self.rq_args = dict(resolution=resolution, buffersize=buffersize, + seed=seed) + + def add(self, condition, incoming): + if condition not in self.running_quantiles: + self.running_quantiles[condition] = RunningQuantile(**self.rq_args) + if self.first_rq is None: + self.first_rq = self.running_quantiles[condition] + self.call_stats[condition] += 1 + rq = self.running_quantiles[condition] + # For performance reasons, the caller can move some conditions to + # the CPU if they are not among the most common conditions. + if rq.device is not None and (rq.device != incoming.device): + rq.to_(incoming.device) + self.running_quantiles[condition].add(incoming) + + def most_common_conditions(self, n): + return sorted(self.call_stats.keys(), + key=lambda c: -self.call_stats[c])[:n] + + def collected_add(self, conditions, incoming): + for c in conditions: + self.add(c, incoming) + + def conditional(self, c): + return self.running_quantiles[c] + + def collected_quantiles(self, conditions, quantiles, old_style=False): + result = torch.zeros( + size=(len(conditions), self.first_rq.depth, len(quantiles)), + dtype=self.first_rq.dtype, + device=self.first_rq.device) + for i, c in enumerate(conditions): + if c in self.running_quantiles: + result[i] = self.running_quantiles[c].quantiles( + quantiles, old_style) + return result + + def collected_normalize(self, conditions, values): + result = torch.zeros( + size=(len(conditions), values.shape[0], values.shape[1]), + dtype=torch.float, + device=self.first_rq.device) + for i, c in enumerate(conditions): + if c in self.running_quantiles: + result[i] = self.running_quantiles[c].normalize(values) + return result + + def to_(self, device, conditions=None): + if conditions is None: + conditions = self.running_quantiles.keys() + for cond in conditions: + if cond in self.running_quantiles: + self.running_quantiles[cond].to_(device) + + def state_dict(self): + conditions = sorted(self.running_quantiles.keys()) + result = dict( + constructor=self.__module__ + '.' + + self.__class__.__name__ + '()', + rq_args=self.rq_args, + conditions=conditions) + for i, c in enumerate(conditions): + result.update({ + '%d.%s' % (i, k): v + for k, v in self.running_quantiles[c].state_dict().items()}) + return result + + def set_state_dict(self, dic): + self.rq_args = dic['rq_args'].item() + conditions = list(dic['conditions']) + subdicts = defaultdict(dict) + for k, v in dic.items(): + if '.' in k: + p, s = k.split('.', 1) + subdicts[p][s] = v + self.running_quantiles = { + c: RunningQuantile(state=subdicts[str(i)]) + for i, c in enumerate(conditions)} + if conditions: + self.first_rq = self.running_quantiles[conditions[0]] + + # example usage: + # levels = rqc.conditional(()).quantiles(1 - fracs) + # denoms = 1 - rqc.collected_normalize(cats, levels) + # isects = 1 - rqc.collected_normalize(labels, levels) + # unions = fracs + denoms[cats] - isects + # iou = isects / unions + + + + +class RunningCrossCovariance: + ''' + Running computation. Use this when an off-diagonal block of the + covariance matrix is needed (e.g., when the whole covariance matrix + does not fit in the GPU). + + Chan-style numerically stable update of mean and full covariance matrix. + Chan, Golub. LeVeque. 1983. http://www.jstor.org/stable/2683386 + ''' + def __init__(self, state=None): + if state is not None: + self.set_state_dict(state) + return + self.count = 0 + self._mean = None + self.cmom2 = None + self.v_cmom2 = None + + def add(self, a, b): + if len(a.shape) == 1: + a = a[None, :] + b = b[None, :] + assert(a.shape[0] == b.shape[0]) + if len(a.shape) > 2: + a, b = [d.view(d.shape[0], d.shape[1], -1).permute(0, 2, 1 + ).contiguous().view(-1, d.shape[1]) for d in [a, b]] + batch_count = a.shape[0] + batch_mean = [d.sum(0) / batch_count for d in [a, b]] + centered = [d - bm for d, bm in zip([a, b], batch_mean)] + # If more than 10 billion operations, divide into batches. + sub_batch = -(-(10 << 30) // (a.shape[1] * b.shape[1])) + # Initial batch. + if self._mean is None: + self.count = batch_count + self._mean = batch_mean + self.v_cmom2 = [c.pow(2).sum(0) for c in centered] + self.cmom2 = a.new(a.shape[1], b.shape[1]).zero_() + progress_addbmm(self.cmom2, centered[0][:,:,None], + centered[1][:,None,:], sub_batch) + return + # Update a batch using Chan-style update for numerical stability. + oldcount = self.count + self.count += batch_count + new_frac = float(batch_count) / self.count + # Update the mean according to the batch deviation from the old mean. + delta = [bm.sub_(m).mul_(new_frac) + for bm, m in zip(batch_mean, self._mean)] + for m, d in zip(self._mean, delta): + m.add_(d) + # Update the cross-covariance using the batch deviation + progress_addbmm(self.cmom2, centered[0][:,:,None], + centered[1][:,None,:], sub_batch) + self.cmom2.addmm_(alpha=new_frac * oldcount, + mat1=delta[0][:,None], mat2=delta[1][None,:]) + # Update the variance using the batch deviation + for c, vc2, d in zip(centered, self.v_cmom2, delta): + vc2.add_(c.pow(2).sum(0)) + vc2.add_(d.pow_(2).mul_(new_frac * oldcount)) + + def mean(self): + return self._mean + + def variance(self): + return [vc2 / (self.count - 1) for vc2 in self.v_cmom2] + + def stdev(self): + return [v.sqrt() for v in self.variance()] + + def covariance(self): + return self.cmom2 / (self.count - 1) + + def correlation(self): + covariance = self.covariance() + rstdev = [s.reciprocal() for s in self.stdev()] + cor = rstdev[0][:,None] * covariance * rstdev[1][None,:] + # Remove NaNs + cor[torch.isnan(cor)] = 0 + return cor + + def to_(self, device): + self._mean = [m.to(device) for m in self._mean] + self.v_cmom2 = [vcs.to(device) for vcs in self.v_cmom2] + self.cmom2 = self.cmom2.to(device) + + def state_dict(self): + return dict( + constructor=self.__module__ + '.' + + self.__class__.__name__ + '()', + count=self.count, + mean_a=self._mean[0].cpu().numpy(), + mean_b=self._mean[1].cpu().numpy(), + cmom2_a=self.v_cmom2[0].cpu().numpy(), + cmom2_b=self.v_cmom2[1].cpu().numpy(), + cmom2=self.cmom2.cpu().numpy()) + + def set_state_dict(self, dic): + self.count = dic['count'].item() + self._mean = [torch.from_numpy(dic[k]) for k in ['mean_a', 'mean_b']] + self.v_cmom2 = [torch.from_numpy(dic[k]) + for k in ['cmom2_a', 'cmom2_b']] + self.cmom2 = torch.from_numpy(dic['cmom2']) + +def progress_addbmm(accum, x, y, batch_size): + ''' + Break up very large adbmm operations into batches so progress can be seen. + ''' + from .progress import default_progress + if x.shape[0] <= batch_size: + return accum.addbmm_(x, y) + progress = default_progress(None) + for i in progress(range(0, x.shape[0], batch_size), desc='bmm'): + accum.addbmm_(x[i:i+batch_size], y[i:i+batch_size]) + return accum + + +def sample_portion(vec, p=0.5): + bits = torch.bernoulli(torch.zeros(vec.shape[0], dtype=torch.uint8, + device=vec.device), p) + return vec[bits] + +if __name__ == '__main__': + import warnings + warnings.filterwarnings("error") + import time + import argparse + parser = argparse.ArgumentParser( + description='Test things out') + parser.add_argument('--mode', default='cpu', help='cpu or cuda') + parser.add_argument('--test_size', type=int, default=1000000) + args = parser.parse_args() + + # An adverarial case: we keep finding more numbers in the middle + # as the stream goes on. + amount = args.test_size + quantiles = 1000 + data = numpy.arange(float(amount)) + data[1::2] = data[-1::-2] + (len(data) - 1) + data /= 2 + depth = 50 + test_cuda = torch.cuda.is_available() + alldata = data[:,None] + (numpy.arange(depth) * amount)[None, :] + actual_sum = torch.FloatTensor(numpy.sum(alldata * alldata, axis=0)) + amt = amount // depth + for r in range(depth): + numpy.random.shuffle(alldata[r*amt:r*amt+amt,r]) + if args.mode == 'cuda': + alldata = torch.cuda.FloatTensor(alldata) + dtype = torch.float + device = torch.device('cuda') + else: + alldata = torch.FloatTensor(alldata) + dtype = torch.float + device = None + starttime = time.time() + qc = RunningQuantile(resolution=6 * 1024) + qc.add(alldata) + # Test state dict + saved = qc.state_dict() + # numpy.savez('foo.npz', **saved) + # saved = numpy.load('foo.npz') + qc = RunningQuantile(state=saved) + assert not qc.device.type == 'cuda' + qc.add(alldata) + actual_sum *= 2 + ro = qc.readout(1001).cpu() + endtime = time.time() + gt = torch.linspace(0, amount, quantiles+1)[None,:] + ( + torch.arange(qc.depth, dtype=torch.float) * amount)[:,None] + maxreldev = torch.max(torch.abs(ro - gt) / amount) * quantiles + print("Maximum relative deviation among %d perentiles: %f" % ( + quantiles, maxreldev)) + minerr = torch.max(torch.abs(qc.minmax().cpu()[:,0] - + torch.arange(qc.depth, dtype=torch.float) * amount)) + maxerr = torch.max(torch.abs((qc.minmax().cpu()[:, -1] + 1) - + (torch.arange(qc.depth, dtype=torch.float) + 1) * amount)) + print("Minmax error %f, %f" % (minerr, maxerr)) + interr = torch.max(torch.abs(qc.integrate(lambda x: x * x).cpu() + - actual_sum) / actual_sum) + print("Integral error: %f" % interr) + medianerr = torch.max(torch.abs(qc.median() - + alldata.median(0)[0]) / alldata.median(0)[0]).cpu() + print("Median error: %f" % interr) + meanerr = torch.max( + torch.abs(qc.mean() - alldata.mean(0)) / alldata.mean(0)).cpu() + print("Mean error: %f" % meanerr) + varerr = torch.max( + torch.abs(qc.variance() - alldata.var(0)) / alldata.var(0)).cpu() + print("Variance error: %f" % varerr) + counterr = ((qc.integrate(lambda x: torch.ones(x.shape[-1]).cpu()) + - qc.size) / (0.0 + qc.size)).item() + print("Count error: %f" % counterr) + print("Time %f" % (endtime - starttime)) + # Algorithm is randomized, so some of these will fail with low probability. + assert maxreldev < 1.0 + assert minerr == 0.0 + assert maxerr == 0.0 + assert interr < 0.01 + assert abs(counterr) < 0.001 + print("OK") diff --git a/netdissect/sampler.py b/netdissect/sampler.py new file mode 100644 index 0000000000000000000000000000000000000000..72f1b46da117403c7f6ddcc1877bd9d70ded962b --- /dev/null +++ b/netdissect/sampler.py @@ -0,0 +1,134 @@ +''' +A sampler is just a list of integer listing the indexes of the +inputs in a data set to sample. For reproducibility, the +FixedRandomSubsetSampler uses a seeded prng to produce the same +sequence always. FixedSubsetSampler is just a wrapper for an +explicit list of integers. + +coordinate_sample solves another sampling problem: when testing +convolutional outputs, we can reduce data explosing by sampling +random points of the feature map rather than the entire feature map. +coordinate_sample does this in a deterministic way that is also +resolution-independent. +''' + +import numpy +import random +from torch.utils.data.sampler import Sampler + +class FixedSubsetSampler(Sampler): + """Represents a fixed sequence of data set indices. + Subsets can be created by specifying a subset of output indexes. + """ + def __init__(self, samples): + self.samples = samples + + def __iter__(self): + return iter(self.samples) + + def __len__(self): + return len(self.samples) + + def __getitem__(self, key): + return self.samples[key] + + def subset(self, new_subset): + return FixedSubsetSampler(self.dereference(new_subset)) + + def dereference(self, indices): + ''' + Translate output sample indices (small numbers indexing the sample) + to input sample indices (larger number indexing the original full set) + ''' + return [self.samples[i] for i in indices] + + +class FixedRandomSubsetSampler(FixedSubsetSampler): + """Samples a fixed number of samples from the dataset, deterministically. + Arguments: + data_source, + sample_size, + seed (optional) + """ + def __init__(self, data_source, start=None, end=None, seed=1): + rng = random.Random(seed) + shuffled = list(range(len(data_source))) + rng.shuffle(shuffled) + self.data_source = data_source + super(FixedRandomSubsetSampler, self).__init__(shuffled[start:end]) + + def class_subset(self, class_filter): + ''' + Returns only the subset matching the given rule. + ''' + if isinstance(class_filter, int): + rule = lambda d: d[1] == class_filter + else: + rule = class_filter + return self.subset([i for i, j in enumerate(self.samples) + if rule(self.data_source[j])]) + +def coordinate_sample(shape, sample_size, seeds, grid=13, seed=1, flat=False): + ''' + Returns a (end-start) sets of sample_size grid points within + the shape given. If the shape dimensions are a multiple of 'grid', + then sampled points within the same row will never be duplicated. + ''' + if flat: + sampind = numpy.zeros((len(seeds), sample_size), dtype=int) + else: + sampind = numpy.zeros((len(seeds), 2, sample_size), dtype=int) + assert sample_size <= grid + for j, seed in enumerate(seeds): + rng = numpy.random.RandomState(seed) + # Shuffle the 169 random grid squares, and pick :sample_size. + square_count = grid ** len(shape) + square = numpy.stack(numpy.unravel_index( + rng.choice(square_count, square_count)[:sample_size], + (grid,) * len(shape))) + # Then add a random offset to each x, y and put in the range [0...1) + # Notice this selects the same locations regardless of resolution. + uniform = (square + rng.uniform(size=square.shape)) / grid + # TODO: support affine scaling so that we can align receptive field + # centers exactly when sampling neurons in different layers. + coords = (uniform * numpy.array(shape)[:,None]).astype(int) + # Now take sample_size without replacement. We do this in a way + # such that if sample_size is decreased or increased up to 'grid', + # the selected points become a subset, not totally different points. + if flat: + sampind[j] = numpy.ravel_multi_index(coords, dims=shape) + else: + sampind[j] = coords + return sampind + +if __name__ == '__main__': + from numpy.testing import assert_almost_equal + # Test that coordinate_sample is deterministic, in-range, and scalable. + assert_almost_equal(coordinate_sample((26, 26), 10, range(101, 102)), + [[[14, 0, 12, 11, 8, 13, 11, 20, 7, 20], + [ 9, 22, 7, 11, 23, 18, 21, 15, 2, 5]]]) + assert_almost_equal(coordinate_sample((13, 13), 10, range(101, 102)), + [[[ 7, 0, 6, 5, 4, 6, 5, 10, 3, 20 // 2], + [ 4, 11, 3, 5, 11, 9, 10, 7, 1, 5 // 2]]]) + assert_almost_equal(coordinate_sample((13, 13), 10, range(100, 102), + flat=True), + [[ 8, 24, 67, 103, 87, 79, 138, 94, 98, 53], + [ 95, 11, 81, 70, 63, 87, 75, 137, 40, 2+10*13]]) + assert_almost_equal(coordinate_sample((13, 13), 10, range(101, 103), + flat=True), + [[ 95, 11, 81, 70, 63, 87, 75, 137, 40, 132], + [ 0, 78, 114, 111, 66, 45, 72, 73, 79, 135]]) + assert_almost_equal(coordinate_sample((26, 26), 10, range(101, 102), + flat=True), + [[373, 22, 319, 297, 231, 356, 307, 535, 184, 5+20*26]]) + # Test FixedRandomSubsetSampler + fss = FixedRandomSubsetSampler(range(10)) + assert len(fss) == 10 + assert_almost_equal(list(fss), [8, 0, 3, 4, 5, 2, 9, 6, 7, 1]) + fss = FixedRandomSubsetSampler(range(10), 3, 8) + assert len(fss) == 5 + assert_almost_equal(list(fss), [4, 5, 2, 9, 6]) + fss = FixedRandomSubsetSampler([(i, i % 3) for i in range(10)], + class_filter=1) + assert len(fss) == 3 + assert_almost_equal(list(fss), [4, 7, 1]) diff --git a/netdissect/segdata.py b/netdissect/segdata.py new file mode 100644 index 0000000000000000000000000000000000000000..f3cb6dfac8985d9c55344abbc26cc26c4862aa85 --- /dev/null +++ b/netdissect/segdata.py @@ -0,0 +1,74 @@ +import os, numpy, torch, json +from .parallelfolder import ParallelImageFolders +from torchvision import transforms +from torchvision.transforms.functional import to_tensor, normalize + +class FieldDef(object): + def __init__(self, field, index, bitshift, bitmask, labels): + self.field = field + self.index = index + self.bitshift = bitshift + self.bitmask = bitmask + self.labels = labels + +class MultiSegmentDataset(object): + ''' + Just like ClevrMulticlassDataset, but the second stream is a one-hot + segmentation tensor rather than a flat one-hot presence vector. + + MultiSegmentDataset('dataset/clevrseg', + imgdir='images/train/positive', + segdir='images/train/segmentation') + ''' + def __init__(self, directory, transform=None, + imgdir='img', segdir='seg', val=False, size=None): + self.segdataset = ParallelImageFolders( + [os.path.join(directory, imgdir), + os.path.join(directory, segdir)], + transform=transform) + self.fields = [] + with open(os.path.join(directory, 'labelnames.json'), 'r') as f: + for defn in json.load(f): + self.fields.append(FieldDef( + defn['field'], defn['index'], defn['bitshift'], + defn['bitmask'], defn['label'])) + self.labels = ['-'] # Reserve label 0 to mean "no label" + self.categories = [] + self.label_category = [0] + for fieldnum, f in enumerate(self.fields): + self.categories.append(f.field) + f.firstchannel = len(self.labels) + f.channels = len(f.labels) - 1 + for lab in f.labels[1:]: + self.labels.append(lab) + self.label_category.append(fieldnum) + # Reserve 25% of the dataset for validation. + first_val = int(len(self.segdataset) * 0.75) + self.val = val + self.first = first_val if val else 0 + self.length = len(self.segdataset) - first_val if val else first_val + # Truncate the dataset if requested. + if size: + self.length = min(size, self.length) + + def __len__(self): + return self.length + + def __getitem__(self, index): + img, segimg = self.segdataset[index + self.first] + segin = numpy.array(segimg, numpy.uint8, copy=False) + segout = torch.zeros(len(self.categories), + segin.shape[0], segin.shape[1], dtype=torch.int64) + for i, field in enumerate(self.fields): + fielddata = ((torch.from_numpy(segin[:, :, field.index]) + >> field.bitshift) & field.bitmask) + segout[i] = field.firstchannel + fielddata - 1 + bincount = numpy.bincount(segout.flatten(), + minlength=len(self.labels)) + return img, segout, bincount + +if __name__ == '__main__': + ds = MultiSegmentDataset('dataset/clevrseg') + print(ds[0]) + import pdb; pdb.set_trace() + diff --git a/netdissect/segmenter.py b/netdissect/segmenter.py new file mode 100644 index 0000000000000000000000000000000000000000..e5ebe364bc30f32581f0d560e11f08bfbd0d1731 --- /dev/null +++ b/netdissect/segmenter.py @@ -0,0 +1,581 @@ +# Usage as a simple differentiable segmenter base class + +import os, torch, numpy, json, glob +import skimage.morphology +from collections import OrderedDict +from netdissect import upsegmodel +from netdissect import segmodel as segmodel_module +from netdissect.easydict import EasyDict +from urllib.request import urlretrieve + +class BaseSegmenter: + def get_label_and_category_names(self): + ''' + Returns two lists: first, a list of tuples [(label, category), ...] + where the label and category are human-readable strings indicating + the meaning of a segmentation class. The 0th segmentation class + should be reserved for a label ('-') that means "no prediction." + The second list should just be a list of [category,...] listing + all categories in a canonical order. + ''' + raise NotImplemented() + + def segment_batch(self, tensor_images, downsample=1): + ''' + Returns a multilabel segmentation for the given batch of (RGB [-1...1]) + images. Each pixel of the result is a torch.long indicating a + predicted class number. Multiple classes can be predicted for + the same pixel: output shape is (n, multipred, y, x), where + multipred is 3, 5, or 6, for how many different predicted labels can + be given for each pixel (depending on whether subdivision is being + used). If downsample is specified, then the output y and x dimensions + are downsampled from the original image. + ''' + raise NotImplemented() + + def predict_single_class(self, tensor_images, classnum, downsample=1): + ''' + Given a batch of images (RGB, normalized to [-1...1]) and + a specific segmentation class number, returns a tuple with + (1) a differentiable ([0..1]) prediction score for the class + at every pixel of the input image. + (2) a binary mask showing where in the input image the + specified class is the best-predicted label for the pixel. + Does not work on subdivided labels. + ''' + raise NotImplemented() + +class UnifiedParsingSegmenter(BaseSegmenter): + ''' + This is a wrapper for a more complicated multi-class segmenter, + as described in https://arxiv.org/pdf/1807.10221.pdf, and as + released in https://github.com/CSAILVision/unifiedparsing. + For our purposes and to simplify processing, we do not use + whole-scene predictions, and we only consume part segmentations + for the three largest object classes (sky, building, person). + ''' + + def __init__(self, segsizes=None, segdiv=None): + # Create a segmentation model + if segsizes is None: + segsizes = [256] + if segdiv == None: + segdiv = 'undivided' + segvocab = 'upp' + segarch = ('resnet50', 'upernet') + epoch = 40 + segmodel = load_unified_parsing_segmentation_model( + segarch, segvocab, epoch) + segmodel.cuda() + self.segmodel = segmodel + self.segsizes = segsizes + self.segdiv = segdiv + mult = 1 + if self.segdiv == 'quad': + mult = 5 + self.divmult = mult + # Assign class numbers for parts. + first_partnumber = ( + (len(segmodel.labeldata['object']) - 1) * mult + 1 + + (len(segmodel.labeldata['material']) - 1)) + # We only use parts for these three types of objects, for efficiency. + partobjects = ['sky', 'building', 'person'] + partnumbers = {} + partnames = [] + objectnumbers = {k: v + for v, k in enumerate(segmodel.labeldata['object'])} + part_index_translation = [] + # We merge some classes. For example "door" is both an object + # and a part of a building. To avoid confusion, we just count + # such classes as objects, and add part scores to the same index. + for owner in partobjects: + part_list = segmodel.labeldata['object_part'][owner] + numeric_part_list = [] + for part in part_list: + if part in objectnumbers: + numeric_part_list.append(objectnumbers[part]) + elif part in partnumbers: + numeric_part_list.append(partnumbers[part]) + else: + partnumbers[part] = len(partnames) + first_partnumber + partnames.append(part) + numeric_part_list.append(partnumbers[part]) + part_index_translation.append(torch.tensor(numeric_part_list)) + self.objects_with_parts = [objectnumbers[obj] for obj in partobjects] + self.part_index = part_index_translation + self.part_names = partnames + # For now we'll just do object and material labels. + self.num_classes = 1 + ( + len(segmodel.labeldata['object']) - 1) * mult + ( + len(segmodel.labeldata['material']) - 1) + len(partnames) + self.num_object_classes = len(self.segmodel.labeldata['object']) - 1 + + def get_label_and_category_names(self, dataset=None): + ''' + Lists label and category names. + ''' + # Labels are ordered as follows: + # 0, [object labels] [divided object labels] [materials] [parts] + # The zero label is reserved to mean 'no prediction'. + if self.segdiv == 'quad': + suffixes = ['t', 'l', 'b', 'r'] + else: + suffixes = [] + divided_labels = [] + for suffix in suffixes: + divided_labels.extend([('%s-%s' % (label, suffix), 'part') + for label in self.segmodel.labeldata['object'][1:]]) + # Create the whole list of labels + labelcats = ( + [(label, 'object') + for label in self.segmodel.labeldata['object']] + + divided_labels + + [(label, 'material') + for label in self.segmodel.labeldata['material'][1:]] + + [(label, 'part') for label in self.part_names]) + return labelcats, ['object', 'part', 'material'] + + def raw_seg_prediction(self, tensor_images, downsample=1): + ''' + Generates a segmentation by applying multiresolution voting on + the segmentation model, using (rounded to 32 pixels) a set of + resolutions in the example benchmark code. + ''' + y, x = tensor_images.shape[2:] + b = len(tensor_images) + tensor_images = (tensor_images + 1) / 2 * 255 + tensor_images = torch.flip(tensor_images, (1,)) # BGR!!!? + tensor_images -= torch.tensor([102.9801, 115.9465, 122.7717]).to( + dtype=tensor_images.dtype, device=tensor_images.device + )[None,:,None,None] + seg_shape = (y // downsample, x // downsample) + # We want these to be multiples of 32 for the model. + sizes = [(s, s) for s in self.segsizes] + pred = {category: torch.zeros( + len(tensor_images), len(self.segmodel.labeldata[category]), + seg_shape[0], seg_shape[1]).cuda() + for category in ['object', 'material']} + part_pred = {partobj_index: torch.zeros( + len(tensor_images), len(partindex), + seg_shape[0], seg_shape[1]).cuda() + for partobj_index, partindex in enumerate(self.part_index)} + for size in sizes: + if size == tensor_images.shape[2:]: + resized = tensor_images + else: + resized = torch.nn.AdaptiveAvgPool2d(size)(tensor_images) + r_pred = self.segmodel( + dict(img=resized), seg_size=seg_shape) + for k in pred: + pred[k] += r_pred[k] + for k in part_pred: + part_pred[k] += r_pred['part'][k] + return pred, part_pred + + def segment_batch(self, tensor_images, downsample=1): + ''' + Returns a multilabel segmentation for the given batch of (RGB [-1...1]) + images. Each pixel of the result is a torch.long indicating a + predicted class number. Multiple classes can be predicted for + the same pixel: output shape is (n, multipred, y, x), where + multipred is 3, 5, or 6, for how many different predicted labels can + be given for each pixel (depending on whether subdivision is being + used). If downsample is specified, then the output y and x dimensions + are downsampled from the original image. + ''' + pred, part_pred = self.raw_seg_prediction(tensor_images, + downsample=downsample) + piece_channels = 2 if self.segdiv == 'quad' else 0 + y, x = tensor_images.shape[2:] + seg_shape = (y // downsample, x // downsample) + segs = torch.zeros(len(tensor_images), 3 + piece_channels, + seg_shape[0], seg_shape[1], + dtype=torch.long, device=tensor_images.device) + _, segs[:,0] = torch.max(pred['object'], dim=1) + # Get materials and translate to shared numbering scheme + _, segs[:,1] = torch.max(pred['material'], dim=1) + maskout = (segs[:,1] == 0) + segs[:,1] += (len(self.segmodel.labeldata['object']) - 1) * self.divmult + segs[:,1][maskout] = 0 + # Now deal with subparts of sky, buildings, people + for i, object_index in enumerate(self.objects_with_parts): + trans = self.part_index[i].to(segs.device) + # Get the argmax, and then translate to shared numbering scheme + seg = trans[torch.max(part_pred[i], dim=1)[1]] + # Only trust the parts where the prediction also predicts the + # owning object. + mask = (segs[:,0] == object_index) + segs[:,2][mask] = seg[mask] + + if self.segdiv == 'quad': + segs = self.expand_segment_quad(segs, self.segdiv) + return segs + + def predict_single_class(self, tensor_images, classnum, downsample=1): + ''' + Given a batch of images (RGB, normalized to [-1...1]) and + a specific segmentation class number, returns a tuple with + (1) a differentiable ([0..1]) prediction score for the class + at every pixel of the input image. + (2) a binary mask showing where in the input image the + specified class is the best-predicted label for the pixel. + Does not work on subdivided labels. + ''' + result = 0 + pred, part_pred = self.raw_seg_prediction(tensor_images, + downsample=downsample) + material_offset = (len(self.segmodel.labeldata['object']) - 1 + ) * self.divmult + if material_offset < classnum < material_offset + len( + self.segmodel.labeldata['material']): + return ( + pred['material'][:, classnum - material_offset], + pred['material'].max(dim=1)[1] == classnum - material_offset) + mask = None + if classnum < len(self.segmodel.labeldata['object']): + result = pred['object'][:, classnum] + mask = (pred['object'].max(dim=1)[1] == classnum) + # Some objects, like 'door', are also a part of other objects, + # so add the part prediction also. + for i, object_index in enumerate(self.objects_with_parts): + local_index = (self.part_index[i] == classnum).nonzero() + if len(local_index) == 0: + continue + local_index = local_index.item() + # Ignore part predictions outside the mask. (We could pay + # atttention to and penalize such predictions.) + mask2 = (pred['object'].max(dim=1)[1] == object_index) * ( + part_pred[i].max(dim=1)[1] == local_index) + if mask is None: + mask = mask2 + else: + mask = torch.max(mask, mask2) + result = result + (part_pred[i][:, local_index]) + assert result is not 0, 'unrecognized class %d' % classnum + return result, mask + + def expand_segment_quad(self, segs, segdiv='quad'): + shape = segs.shape + segs[:,3:] = segs[:,0:1] # start by copying the object channel + num_seg_labels = self.num_object_classes + # For every connected component present (using generator) + for i, mask in component_masks(segs[:,0:1]): + # Figure the bounding box of the label + top, bottom = mask.any(dim=1).nonzero()[[0, -1], 0] + left, right = mask.any(dim=0).nonzero()[[0, -1], 0] + # Chop the bounding box into four parts + vmid = (top + bottom + 1) // 2 + hmid = (left + right + 1) // 2 + # Construct top, bottom, right, left masks + quad_mask = mask[None,:,:].repeat(4, 1, 1) + quad_mask[0, vmid:, :] = 0 # top + quad_mask[1, :, hmid:] = 0 # right + quad_mask[2, :vmid, :] = 0 # bottom + quad_mask[3, :, :hmid] = 0 # left + quad_mask = quad_mask.long() + # Modify extra segmentation labels by offsetting + segs[i,3,:,:] += quad_mask[0] * num_seg_labels + segs[i,4,:,:] += quad_mask[1] * (2 * num_seg_labels) + segs[i,3,:,:] += quad_mask[2] * (3 * num_seg_labels) + segs[i,4,:,:] += quad_mask[3] * (4 * num_seg_labels) + # remove any components that were too small to subdivide + mask = segs[:,3:] <= self.num_object_classes + segs[:,3:][mask] = 0 + return segs + +class SemanticSegmenter(BaseSegmenter): + def __init__(self, modeldir=None, segarch=None, segvocab=None, + segsizes=None, segdiv=None, epoch=None): + # Create a segmentation model + if modeldir == None: + modeldir = 'dataset/segmodel' + if segvocab == None: + segvocab = 'baseline' + if segarch == None: + segarch = ('resnet50_dilated8', 'ppm_bilinear_deepsup') + if segdiv == None: + segdiv = 'undivided' + elif isinstance(segarch, str): + segarch = segarch.split(',') + segmodel = load_segmentation_model(modeldir, segarch, segvocab, epoch) + if segsizes is None: + segsizes = getattr(segmodel.meta, 'segsizes', [256]) + self.segsizes = segsizes + # Verify segmentation model to has every out_channel labeled. + assert len(segmodel.meta.labels) == list(c for c in segmodel.modules() + if isinstance(c, torch.nn.Conv2d))[-1].out_channels + segmodel.cuda() + self.segmodel = segmodel + self.segdiv = segdiv + # Image normalization + self.bgr = (segmodel.meta.imageformat.byteorder == 'BGR') + self.imagemean = torch.tensor(segmodel.meta.imageformat.mean) + self.imagestd = torch.tensor(segmodel.meta.imageformat.stdev) + # Map from labels to external indexes, and labels to channel sets. + self.labelmap = {'-': 0} + self.channelmap = {'-': []} + self.labels = [('-', '-')] + num_labels = 1 + self.num_underlying_classes = len(segmodel.meta.labels) + # labelmap maps names to external indexes. + for i, label in enumerate(segmodel.meta.labels): + if label.name not in self.channelmap: + self.channelmap[label.name] = [] + self.channelmap[label.name].append(i) + if getattr(label, 'internal', None) or label.name in self.labelmap: + continue + self.labelmap[label.name] = num_labels + num_labels += 1 + self.labels.append((label.name, label.category)) + # Each category gets its own independent softmax. + self.category_indexes = { category.name: + [i for i, label in enumerate(segmodel.meta.labels) + if label.category == category.name] + for category in segmodel.meta.categories } + # catindexmap maps names to category internal indexes + self.catindexmap = {} + for catname, indexlist in self.category_indexes.items(): + for index, i in enumerate(indexlist): + self.catindexmap[segmodel.meta.labels[i].name] = ( + (catname, index)) + # After the softmax, each category is mapped to external indexes. + self.category_map = { catname: + torch.tensor([ + self.labelmap.get(segmodel.meta.labels[ind].name, 0) + for ind in catindex]) + for catname, catindex in self.category_indexes.items()} + self.category_rules = segmodel.meta.categories + # Finally, naive subdivision can be applied. + mult = 1 + if self.segdiv == 'quad': + mult = 5 + suffixes = ['t', 'l', 'b', 'r'] + divided_labels = [] + for suffix in suffixes: + divided_labels.extend([('%s-%s' % (label, suffix), cat) + for label, cat in self.labels[1:]]) + self.channelmap.update({ + '%s-%s' % (label, suffix): self.channelmap[label] + for label, cat in self.labels[1:] }) + self.labels.extend(divided_labels) + # For examining a single class + self.channellist = [self.channelmap[name] for name, _ in self.labels] + + def get_label_and_category_names(self, dataset=None): + return self.labels, self.segmodel.categories + + def segment_batch(self, tensor_images, downsample=1): + return self.raw_segment_batch(tensor_images, downsample)[0] + + def raw_segment_batch(self, tensor_images, downsample=1): + pred = self.raw_seg_prediction(tensor_images, downsample) + catsegs = {} + for catkey, catindex in self.category_indexes.items(): + _, segs = torch.max(pred[:, catindex], dim=1) + catsegs[catkey] = segs + masks = {} + segs = torch.zeros(len(tensor_images), len(self.category_rules), + pred.shape[2], pred.shape[2], device=pred.device, + dtype=torch.long) + for i, cat in enumerate(self.category_rules): + catmap = self.category_map[cat.name].to(pred.device) + translated = catmap[catsegs[cat.name]] + if getattr(cat, 'mask', None) is not None: + if cat.mask not in masks: + maskcat, maskind = self.catindexmap[cat.mask] + masks[cat.mask] = (catsegs[maskcat] == maskind) + translated *= masks[cat.mask].long() + segs[:,i] = translated + if self.segdiv == 'quad': + segs = self.expand_segment_quad(segs, + self.num_underlying_classes, self.segdiv) + return segs, pred + + def raw_seg_prediction(self, tensor_images, downsample=1): + ''' + Generates a segmentation by applying multiresolution voting on + the segmentation model, using (rounded to 32 pixels) a set of + resolutions in the example benchmark code. + ''' + y, x = tensor_images.shape[2:] + b = len(tensor_images) + # Flip the RGB order if specified. + if self.bgr: + tensor_images = torch.flip(tensor_images, (1,)) + # Transform from our [-1..1] range to torch standard [0..1] range + # and then apply normalization. + tensor_images = ((tensor_images + 1) / 2 + ).sub_(self.imagemean[None,:,None,None].to(tensor_images.device) + ).div_(self.imagestd[None,:,None,None].to(tensor_images.device)) + # Output shape can be downsampled. + seg_shape = (y // downsample, x // downsample) + # We want these to be multiples of 32 for the model. + sizes = [(s, s) for s in self.segsizes] + pred = torch.zeros( + len(tensor_images), (self.num_underlying_classes), + seg_shape[0], seg_shape[1]).cuda() + for size in sizes: + if size == tensor_images.shape[2:]: + resized = tensor_images + else: + resized = torch.nn.AdaptiveAvgPool2d(size)(tensor_images) + raw_pred = self.segmodel( + dict(img_data=resized), segSize=seg_shape) + softmax_pred = torch.empty_like(raw_pred) + for catindex in self.category_indexes.values(): + softmax_pred[:, catindex] = torch.nn.functional.softmax( + raw_pred[:, catindex], dim=1) + pred += softmax_pred + return pred + + def expand_segment_quad(self, segs, num_seg_labels, segdiv='quad'): + shape = segs.shape + output = segs.repeat(1, 3, 1, 1) + # For every connected component present (using generator) + for i, mask in component_masks(segs): + # Figure the bounding box of the label + top, bottom = mask.any(dim=1).nonzero()[[0, -1], 0] + left, right = mask.any(dim=0).nonzero()[[0, -1], 0] + # Chop the bounding box into four parts + vmid = (top + bottom + 1) // 2 + hmid = (left + right + 1) // 2 + # Construct top, bottom, right, left masks + quad_mask = mask[None,:,:].repeat(4, 1, 1) + quad_mask[0, vmid:, :] = 0 # top + quad_mask[1, :, hmid:] = 0 # right + quad_mask[2, :vmid, :] = 0 # bottom + quad_mask[3, :, :hmid] = 0 # left + quad_mask = quad_mask.long() + # Modify extra segmentation labels by offsetting + output[i,1,:,:] += quad_mask[0] * num_seg_labels + output[i,2,:,:] += quad_mask[1] * (2 * num_seg_labels) + output[i,1,:,:] += quad_mask[2] * (3 * num_seg_labels) + output[i,2,:,:] += quad_mask[3] * (4 * num_seg_labels) + return output + + def predict_single_class(self, tensor_images, classnum, downsample=1): + ''' + Given a batch of images (RGB, normalized to [-1...1]) and + a specific segmentation class number, returns a tuple with + (1) a differentiable ([0..1]) prediction score for the class + at every pixel of the input image. + (2) a binary mask showing where in the input image the + specified class is the best-predicted label for the pixel. + Does not work on subdivided labels. + ''' + seg, pred = self.raw_segment_batch(tensor_images, + downsample=downsample) + result = pred[:,self.channellist[classnum]].sum(dim=1) + mask = (seg == classnum).max(1)[0] + return result, mask + +def component_masks(segmentation_batch): + ''' + Splits connected components into regions (slower, requires cpu). + ''' + npbatch = segmentation_batch.cpu().numpy() + for i in range(segmentation_batch.shape[0]): + labeled, num = skimage.morphology.label(npbatch[i][0], return_num=True) + labeled = torch.from_numpy(labeled).to(segmentation_batch.device) + for label in range(1, num): + yield i, (labeled == label) + +def load_unified_parsing_segmentation_model(segmodel_arch, segvocab, epoch): + segmodel_dir = 'dataset/segmodel/%s-%s-%s' % ((segvocab,) + segmodel_arch) + # Load json of class names and part/object structure + with open(os.path.join(segmodel_dir, 'labels.json')) as f: + labeldata = json.load(f) + nr_classes={k: len(labeldata[k]) + for k in ['object', 'scene', 'material']} + nr_classes['part'] = sum(len(p) for p in labeldata['object_part'].values()) + # Create a segmentation model + segbuilder = upsegmodel.ModelBuilder() + # example segmodel_arch = ('resnet101', 'upernet') + seg_encoder = segbuilder.build_encoder( + arch=segmodel_arch[0], + fc_dim=2048, + weights=os.path.join(segmodel_dir, 'encoder_epoch_%d.pth' % epoch)) + seg_decoder = segbuilder.build_decoder( + arch=segmodel_arch[1], + fc_dim=2048, use_softmax=True, + nr_classes=nr_classes, + weights=os.path.join(segmodel_dir, 'decoder_epoch_%d.pth' % epoch)) + segmodel = upsegmodel.SegmentationModule( + seg_encoder, seg_decoder, labeldata) + segmodel.categories = ['object', 'part', 'material'] + segmodel.eval() + return segmodel + +def load_segmentation_model(modeldir, segmodel_arch, segvocab, epoch=None): + # Load csv of class names + segmodel_dir = 'dataset/segmodel/%s-%s-%s' % ((segvocab,) + segmodel_arch) + with open(os.path.join(segmodel_dir, 'labels.json')) as f: + labeldata = EasyDict(json.load(f)) + # Automatically pick the last epoch available. + if epoch is None: + choices = [os.path.basename(n)[14:-4] for n in + glob.glob(os.path.join(segmodel_dir, 'encoder_epoch_*.pth'))] + epoch = max([int(c) for c in choices if c.isdigit()]) + # Create a segmentation model + segbuilder = segmodel_module.ModelBuilder() + # example segmodel_arch = ('resnet101', 'upernet') + seg_encoder = segbuilder.build_encoder( + arch=segmodel_arch[0], + fc_dim=2048, + weights=os.path.join(segmodel_dir, 'encoder_epoch_%d.pth' % epoch)) + seg_decoder = segbuilder.build_decoder( + arch=segmodel_arch[1], + fc_dim=2048, inference=True, num_class=len(labeldata.labels), + weights=os.path.join(segmodel_dir, 'decoder_epoch_%d.pth' % epoch)) + segmodel = segmodel_module.SegmentationModule(seg_encoder, seg_decoder, + torch.nn.NLLLoss(ignore_index=-1)) + segmodel.categories = [cat.name for cat in labeldata.categories] + segmodel.labels = [label.name for label in labeldata.labels] + categories = OrderedDict() + label_category = numpy.zeros(len(segmodel.labels), dtype=int) + for i, label in enumerate(labeldata.labels): + label_category[i] = segmodel.categories.index(label.category) + segmodel.meta = labeldata + segmodel.eval() + return segmodel + +def ensure_upp_segmenter_downloaded(directory): + baseurl = 'http://netdissect.csail.mit.edu/data/segmodel' + dirname = 'upp-resnet50-upernet' + files = ['decoder_epoch_40.pth', 'encoder_epoch_40.pth', 'labels.json'] + download_dir = os.path.join(directory, dirname) + os.makedirs(download_dir, exist_ok=True) + for fn in files: + if os.path.isfile(os.path.join(download_dir, fn)): + continue # Skip files already downloaded + url = '%s/%s/%s' % (baseurl, dirname, fn) + print('Downloading %s' % url) + urlretrieve(url, os.path.join(download_dir, fn)) + assert os.path.isfile(os.path.join(directory, dirname, 'labels.json')) + +def test_main(): + ''' + Test the unified segmenter. + ''' + from PIL import Image + testim = Image.open('script/testdata/test_church_242.jpg') + tensor_im = (torch.from_numpy(numpy.asarray(testim)).permute(2, 0, 1) + .float() / 255 * 2 - 1)[None, :, :, :].cuda() + segmenter = UnifiedParsingSegmenter() + seg = segmenter.segment_batch(tensor_im) + bc = torch.bincount(seg.view(-1)) + labels, cats = segmenter.get_label_and_category_names() + for label in bc.nonzero()[:,0]: + if label.item(): + # What is the prediction for this class? + pred, mask = segmenter.predict_single_class(tensor_im, label.item()) + assert mask.sum().item() == bc[label].item() + assert len(((seg == label).max(1)[0] - mask).nonzero()) == 0 + inside_pred = pred[mask].mean().item() + outside_pred = pred[~mask].mean().item() + print('%s (%s, #%d): %d pixels, pred %.2g inside %.2g outside' % + (labels[label.item()] + (label.item(), bc[label].item(), + inside_pred, outside_pred))) + +if __name__ == '__main__': + test_main() diff --git a/netdissect/segmodel/__init__.py b/netdissect/segmodel/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..76b40a0a36bc2976f185dbdc344c5a7c09b65920 --- /dev/null +++ b/netdissect/segmodel/__init__.py @@ -0,0 +1 @@ +from .models import ModelBuilder, SegmentationModule diff --git a/netdissect/segmodel/__pycache__/__init__.cpython-310.pyc b/netdissect/segmodel/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5b0528db10fa540f524274f8b27d91477fcaf006 Binary files /dev/null and b/netdissect/segmodel/__pycache__/__init__.cpython-310.pyc differ diff --git a/netdissect/segmodel/__pycache__/models.cpython-310.pyc b/netdissect/segmodel/__pycache__/models.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e1d96bed23f85ffa67d754c5d5124d4c8946e1cb Binary files /dev/null and b/netdissect/segmodel/__pycache__/models.cpython-310.pyc differ diff --git a/netdissect/segmodel/__pycache__/resnet.cpython-310.pyc b/netdissect/segmodel/__pycache__/resnet.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1ab44fc95f272c647be70f888629c35ced60804a Binary files /dev/null and b/netdissect/segmodel/__pycache__/resnet.cpython-310.pyc differ diff --git a/netdissect/segmodel/__pycache__/resnext.cpython-310.pyc b/netdissect/segmodel/__pycache__/resnext.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..26b800dfb4457d174879f59178e840210106bffc Binary files /dev/null and b/netdissect/segmodel/__pycache__/resnext.cpython-310.pyc differ diff --git a/netdissect/segmodel/colors150.npy b/netdissect/segmodel/colors150.npy new file mode 100644 index 0000000000000000000000000000000000000000..2384b386dabded09c47329a360987a0d7f67d697 --- /dev/null +++ b/netdissect/segmodel/colors150.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e9823be654b7a9c135e355952b580f567d5127e98d99ec792ebc349d5fc8c137 +size 578 diff --git a/netdissect/segmodel/models.py b/netdissect/segmodel/models.py new file mode 100644 index 0000000000000000000000000000000000000000..ceb6f2ce21720722d5d8c9ee4f7e015ad06a9647 --- /dev/null +++ b/netdissect/segmodel/models.py @@ -0,0 +1,558 @@ +import torch +import torch.nn as nn +import torchvision +from . import resnet, resnext +try: + from lib.nn import SynchronizedBatchNorm2d +except ImportError: + from torch.nn import BatchNorm2d as SynchronizedBatchNorm2d + + +class SegmentationModuleBase(nn.Module): + def __init__(self): + super(SegmentationModuleBase, self).__init__() + + def pixel_acc(self, pred, label): + _, preds = torch.max(pred, dim=1) + valid = (label >= 0).long() + acc_sum = torch.sum(valid * (preds == label).long()) + pixel_sum = torch.sum(valid) + acc = acc_sum.float() / (pixel_sum.float() + 1e-10) + return acc + + +class SegmentationModule(SegmentationModuleBase): + def __init__(self, net_enc, net_dec, crit, deep_sup_scale=None): + super(SegmentationModule, self).__init__() + self.encoder = net_enc + self.decoder = net_dec + self.crit = crit + self.deep_sup_scale = deep_sup_scale + + def forward(self, feed_dict, *, segSize=None): + if segSize is None: # training + if self.deep_sup_scale is not None: # use deep supervision technique + (pred, pred_deepsup) = self.decoder(self.encoder(feed_dict['img_data'], return_feature_maps=True)) + else: + pred = self.decoder(self.encoder(feed_dict['img_data'], return_feature_maps=True)) + + loss = self.crit(pred, feed_dict['seg_label']) + if self.deep_sup_scale is not None: + loss_deepsup = self.crit(pred_deepsup, feed_dict['seg_label']) + loss = loss + loss_deepsup * self.deep_sup_scale + + acc = self.pixel_acc(pred, feed_dict['seg_label']) + return loss, acc + else: # inference + pred = self.decoder(self.encoder(feed_dict['img_data'], return_feature_maps=True), segSize=segSize) + return pred + + +def conv3x3(in_planes, out_planes, stride=1, has_bias=False): + "3x3 convolution with padding" + return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride, + padding=1, bias=has_bias) + + +def conv3x3_bn_relu(in_planes, out_planes, stride=1): + return nn.Sequential( + conv3x3(in_planes, out_planes, stride), + SynchronizedBatchNorm2d(out_planes), + nn.ReLU(inplace=True), + ) + + +class ModelBuilder(): + # custom weights initialization + def weights_init(self, m): + classname = m.__class__.__name__ + if classname.find('Conv') != -1: + nn.init.kaiming_normal_(m.weight.data) + elif classname.find('BatchNorm') != -1: + m.weight.data.fill_(1.) + m.bias.data.fill_(1e-4) + #elif classname.find('Linear') != -1: + # m.weight.data.normal_(0.0, 0.0001) + + def build_encoder(self, arch='resnet50_dilated8', fc_dim=512, weights=''): + pretrained = True if len(weights) == 0 else False + if arch == 'resnet34': + raise NotImplementedError + orig_resnet = resnet.__dict__['resnet34'](pretrained=pretrained) + net_encoder = Resnet(orig_resnet) + elif arch == 'resnet34_dilated8': + raise NotImplementedError + orig_resnet = resnet.__dict__['resnet34'](pretrained=pretrained) + net_encoder = ResnetDilated(orig_resnet, + dilate_scale=8) + elif arch == 'resnet34_dilated16': + raise NotImplementedError + orig_resnet = resnet.__dict__['resnet34'](pretrained=pretrained) + net_encoder = ResnetDilated(orig_resnet, + dilate_scale=16) + elif arch == 'resnet50': + orig_resnet = resnet.__dict__['resnet50'](pretrained=pretrained) + net_encoder = Resnet(orig_resnet) + elif arch == 'resnet50_dilated8': + orig_resnet = resnet.__dict__['resnet50'](pretrained=pretrained) + net_encoder = ResnetDilated(orig_resnet, + dilate_scale=8) + elif arch == 'resnet50_dilated16': + orig_resnet = resnet.__dict__['resnet50'](pretrained=pretrained) + net_encoder = ResnetDilated(orig_resnet, + dilate_scale=16) + elif arch == 'resnet101': + orig_resnet = resnet.__dict__['resnet101'](pretrained=pretrained) + net_encoder = Resnet(orig_resnet) + elif arch == 'resnet101_dilated8': + orig_resnet = resnet.__dict__['resnet101'](pretrained=pretrained) + net_encoder = ResnetDilated(orig_resnet, + dilate_scale=8) + elif arch == 'resnet101_dilated16': + orig_resnet = resnet.__dict__['resnet101'](pretrained=pretrained) + net_encoder = ResnetDilated(orig_resnet, + dilate_scale=16) + elif arch == 'resnext101': + orig_resnext = resnext.__dict__['resnext101'](pretrained=pretrained) + net_encoder = Resnet(orig_resnext) # we can still use class Resnet + else: + raise Exception('Architecture undefined!') + + # net_encoder.apply(self.weights_init) + if len(weights) > 0: + # print('Loading weights for net_encoder') + net_encoder.load_state_dict( + torch.load(weights, map_location=lambda storage, loc: storage), strict=False) + return net_encoder + + def build_decoder(self, arch='ppm_bilinear_deepsup', + fc_dim=512, num_class=150, + weights='', inference=False, use_softmax=False): + if arch == 'c1_bilinear_deepsup': + net_decoder = C1BilinearDeepSup( + num_class=num_class, + fc_dim=fc_dim, + inference=inference, + use_softmax=use_softmax) + elif arch == 'c1_bilinear': + net_decoder = C1Bilinear( + num_class=num_class, + fc_dim=fc_dim, + inference=inference, + use_softmax=use_softmax) + elif arch == 'ppm_bilinear': + net_decoder = PPMBilinear( + num_class=num_class, + fc_dim=fc_dim, + inference=inference, + use_softmax=use_softmax) + elif arch == 'ppm_bilinear_deepsup': + net_decoder = PPMBilinearDeepsup( + num_class=num_class, + fc_dim=fc_dim, + inference=inference, + use_softmax=use_softmax) + elif arch == 'upernet_lite': + net_decoder = UPerNet( + num_class=num_class, + fc_dim=fc_dim, + inference=inference, + use_softmax=use_softmax, + fpn_dim=256) + elif arch == 'upernet': + net_decoder = UPerNet( + num_class=num_class, + fc_dim=fc_dim, + inference=inference, + use_softmax=use_softmax, + fpn_dim=512) + elif arch == 'upernet_tmp': + net_decoder = UPerNetTmp( + num_class=num_class, + fc_dim=fc_dim, + inference=inference, + use_softmax=use_softmax, + fpn_dim=512) + else: + raise Exception('Architecture undefined!') + + net_decoder.apply(self.weights_init) + if len(weights) > 0: + # print('Loading weights for net_decoder') + net_decoder.load_state_dict( + torch.load(weights, map_location=lambda storage, loc: storage), strict=False) + return net_decoder + + +class Resnet(nn.Module): + def __init__(self, orig_resnet): + super(Resnet, self).__init__() + + # take pretrained resnet, except AvgPool and FC + self.conv1 = orig_resnet.conv1 + self.bn1 = orig_resnet.bn1 + self.relu1 = orig_resnet.relu1 + self.conv2 = orig_resnet.conv2 + self.bn2 = orig_resnet.bn2 + self.relu2 = orig_resnet.relu2 + self.conv3 = orig_resnet.conv3 + self.bn3 = orig_resnet.bn3 + self.relu3 = orig_resnet.relu3 + self.maxpool = orig_resnet.maxpool + self.layer1 = orig_resnet.layer1 + self.layer2 = orig_resnet.layer2 + self.layer3 = orig_resnet.layer3 + self.layer4 = orig_resnet.layer4 + + def forward(self, x, return_feature_maps=False): + conv_out = [] + + x = self.relu1(self.bn1(self.conv1(x))) + x = self.relu2(self.bn2(self.conv2(x))) + x = self.relu3(self.bn3(self.conv3(x))) + x = self.maxpool(x) + + x = self.layer1(x); conv_out.append(x); + x = self.layer2(x); conv_out.append(x); + x = self.layer3(x); conv_out.append(x); + x = self.layer4(x); conv_out.append(x); + + if return_feature_maps: + return conv_out + return [x] + + +class ResnetDilated(nn.Module): + def __init__(self, orig_resnet, dilate_scale=8): + super(ResnetDilated, self).__init__() + from functools import partial + + if dilate_scale == 8: + orig_resnet.layer3.apply( + partial(self._nostride_dilate, dilate=2)) + orig_resnet.layer4.apply( + partial(self._nostride_dilate, dilate=4)) + elif dilate_scale == 16: + orig_resnet.layer4.apply( + partial(self._nostride_dilate, dilate=2)) + + # take pretrained resnet, except AvgPool and FC + self.conv1 = orig_resnet.conv1 + self.bn1 = orig_resnet.bn1 + self.relu1 = orig_resnet.relu1 + self.conv2 = orig_resnet.conv2 + self.bn2 = orig_resnet.bn2 + self.relu2 = orig_resnet.relu2 + self.conv3 = orig_resnet.conv3 + self.bn3 = orig_resnet.bn3 + self.relu3 = orig_resnet.relu3 + self.maxpool = orig_resnet.maxpool + self.layer1 = orig_resnet.layer1 + self.layer2 = orig_resnet.layer2 + self.layer3 = orig_resnet.layer3 + self.layer4 = orig_resnet.layer4 + + def _nostride_dilate(self, m, dilate): + classname = m.__class__.__name__ + if classname.find('Conv') != -1: + # the convolution with stride + if m.stride == (2, 2): + m.stride = (1, 1) + if m.kernel_size == (3, 3): + m.dilation = (dilate//2, dilate//2) + m.padding = (dilate//2, dilate//2) + # other convoluions + else: + if m.kernel_size == (3, 3): + m.dilation = (dilate, dilate) + m.padding = (dilate, dilate) + + def forward(self, x, return_feature_maps=False): + conv_out = [] + + x = self.relu1(self.bn1(self.conv1(x))) + x = self.relu2(self.bn2(self.conv2(x))) + x = self.relu3(self.bn3(self.conv3(x))) + x = self.maxpool(x) + + x = self.layer1(x); conv_out.append(x); + x = self.layer2(x); conv_out.append(x); + x = self.layer3(x); conv_out.append(x); + x = self.layer4(x); conv_out.append(x); + + if return_feature_maps: + return conv_out + return [x] + + +# last conv, bilinear upsample +class C1BilinearDeepSup(nn.Module): + def __init__(self, num_class=150, fc_dim=2048, inference=False, use_softmax=False): + super(C1BilinearDeepSup, self).__init__() + self.use_softmax = use_softmax + self.inference = inference + + self.cbr = conv3x3_bn_relu(fc_dim, fc_dim // 4, 1) + self.cbr_deepsup = conv3x3_bn_relu(fc_dim // 2, fc_dim // 4, 1) + + # last conv + self.conv_last = nn.Conv2d(fc_dim // 4, num_class, 1, 1, 0) + self.conv_last_deepsup = nn.Conv2d(fc_dim // 4, num_class, 1, 1, 0) + + def forward(self, conv_out, segSize=None): + conv5 = conv_out[-1] + + x = self.cbr(conv5) + x = self.conv_last(x) + + if self.inference or self.use_softmax: # is True during inference + x = nn.functional.interpolate( + x, size=segSize, mode='bilinear', align_corners=False) + if self.use_softmax: + x = nn.functional.softmax(x, dim=1) + return x + + # deep sup + conv4 = conv_out[-2] + _ = self.cbr_deepsup(conv4) + _ = self.conv_last_deepsup(_) + + x = nn.functional.log_softmax(x, dim=1) + _ = nn.functional.log_softmax(_, dim=1) + + return (x, _) + + +# last conv, bilinear upsample +class C1Bilinear(nn.Module): + def __init__(self, num_class=150, fc_dim=2048, inference=False, use_softmax=False): + super(C1Bilinear, self).__init__() + self.use_softmax = use_softmax + self.inference = inference + + self.cbr = conv3x3_bn_relu(fc_dim, fc_dim // 4, 1) + + # last conv + self.conv_last = nn.Conv2d(fc_dim // 4, num_class, 1, 1, 0) + + def forward(self, conv_out, segSize=None): + conv5 = conv_out[-1] + x = self.cbr(conv5) + x = self.conv_last(x) + + if self.inference or self.use_softmax: # is True during inference + x = nn.functional.interpolate( + x, size=segSize, mode='bilinear', align_corners=False) + if self.use_softmax: + x = nn.functional.softmax(x, dim=1) + else: + x = nn.functional.log_softmax(x, dim=1) + + return x + + +# pyramid pooling, bilinear upsample +class PPMBilinear(nn.Module): + def __init__(self, num_class=150, fc_dim=4096, + inference=False, use_softmax=False, pool_scales=(1, 2, 3, 6)): + super(PPMBilinear, self).__init__() + self.use_softmax = use_softmax + self.inference = inference + + self.ppm = [] + for scale in pool_scales: + self.ppm.append(nn.Sequential( + nn.AdaptiveAvgPool2d(scale), + nn.Conv2d(fc_dim, 512, kernel_size=1, bias=False), + SynchronizedBatchNorm2d(512), + nn.ReLU(inplace=True) + )) + self.ppm = nn.ModuleList(self.ppm) + + self.conv_last = nn.Sequential( + nn.Conv2d(fc_dim+len(pool_scales)*512, 512, + kernel_size=3, padding=1, bias=False), + SynchronizedBatchNorm2d(512), + nn.ReLU(inplace=True), + nn.Dropout2d(0.1), + nn.Conv2d(512, num_class, kernel_size=1) + ) + + def forward(self, conv_out, segSize=None): + conv5 = conv_out[-1] + + input_size = conv5.size() + ppm_out = [conv5] + for pool_scale in self.ppm: + ppm_out.append(nn.functional.interpolate( + pool_scale(conv5), + (input_size[2], input_size[3]), + mode='bilinear', align_corners=False)) + ppm_out = torch.cat(ppm_out, 1) + + x = self.conv_last(ppm_out) + + if self.inference or self.use_softmax: # is True during inference + x = nn.functional.interpolate( + x, size=segSize, mode='bilinear', align_corners=False) + if self.use_softmax: + x = nn.functional.softmax(x, dim=1) + else: + x = nn.functional.log_softmax(x, dim=1) + return x + + +# pyramid pooling, bilinear upsample +class PPMBilinearDeepsup(nn.Module): + def __init__(self, num_class=150, fc_dim=4096, + inference=False, use_softmax=False, pool_scales=(1, 2, 3, 6)): + super(PPMBilinearDeepsup, self).__init__() + self.use_softmax = use_softmax + self.inference = inference + + self.ppm = [] + for scale in pool_scales: + self.ppm.append(nn.Sequential( + nn.AdaptiveAvgPool2d(scale), + nn.Conv2d(fc_dim, 512, kernel_size=1, bias=False), + SynchronizedBatchNorm2d(512), + nn.ReLU(inplace=True) + )) + self.ppm = nn.ModuleList(self.ppm) + self.cbr_deepsup = conv3x3_bn_relu(fc_dim // 2, fc_dim // 4, 1) + + self.conv_last = nn.Sequential( + nn.Conv2d(fc_dim+len(pool_scales)*512, 512, + kernel_size=3, padding=1, bias=False), + SynchronizedBatchNorm2d(512), + nn.ReLU(inplace=True), + nn.Dropout2d(0.1), + nn.Conv2d(512, num_class, kernel_size=1) + ) + self.conv_last_deepsup = nn.Conv2d(fc_dim // 4, num_class, 1, 1, 0) + self.dropout_deepsup = nn.Dropout2d(0.1) + + def forward(self, conv_out, segSize=None): + conv5 = conv_out[-1] + + input_size = conv5.size() + ppm_out = [conv5] + for pool_scale in self.ppm: + ppm_out.append(nn.functional.interpolate( + pool_scale(conv5), + (input_size[2], input_size[3]), + mode='bilinear', align_corners=False)) + ppm_out = torch.cat(ppm_out, 1) + + x = self.conv_last(ppm_out) + + if self.inference or self.use_softmax: # is True during inference + x = nn.functional.interpolate( + x, size=segSize, mode='bilinear', align_corners=False) + if self.use_softmax: + x = nn.functional.softmax(x, dim=1) + return x + + # deep sup + conv4 = conv_out[-2] + _ = self.cbr_deepsup(conv4) + _ = self.dropout_deepsup(_) + _ = self.conv_last_deepsup(_) + + x = nn.functional.log_softmax(x, dim=1) + _ = nn.functional.log_softmax(_, dim=1) + + return (x, _) + + +# upernet +class UPerNet(nn.Module): + def __init__(self, num_class=150, fc_dim=4096, + inference=False, use_softmax=False, pool_scales=(1, 2, 3, 6), + fpn_inplanes=(256,512,1024,2048), fpn_dim=256): + super(UPerNet, self).__init__() + self.use_softmax = use_softmax + self.inference = inference + + # PPM Module + self.ppm_pooling = [] + self.ppm_conv = [] + + for scale in pool_scales: + self.ppm_pooling.append(nn.AdaptiveAvgPool2d(scale)) + self.ppm_conv.append(nn.Sequential( + nn.Conv2d(fc_dim, 512, kernel_size=1, bias=False), + SynchronizedBatchNorm2d(512), + nn.ReLU(inplace=True) + )) + self.ppm_pooling = nn.ModuleList(self.ppm_pooling) + self.ppm_conv = nn.ModuleList(self.ppm_conv) + self.ppm_last_conv = conv3x3_bn_relu(fc_dim + len(pool_scales)*512, fpn_dim, 1) + + # FPN Module + self.fpn_in = [] + for fpn_inplane in fpn_inplanes[:-1]: # skip the top layer + self.fpn_in.append(nn.Sequential( + nn.Conv2d(fpn_inplane, fpn_dim, kernel_size=1, bias=False), + SynchronizedBatchNorm2d(fpn_dim), + nn.ReLU(inplace=True) + )) + self.fpn_in = nn.ModuleList(self.fpn_in) + + self.fpn_out = [] + for i in range(len(fpn_inplanes) - 1): # skip the top layer + self.fpn_out.append(nn.Sequential( + conv3x3_bn_relu(fpn_dim, fpn_dim, 1), + )) + self.fpn_out = nn.ModuleList(self.fpn_out) + + self.conv_last = nn.Sequential( + conv3x3_bn_relu(len(fpn_inplanes) * fpn_dim, fpn_dim, 1), + nn.Conv2d(fpn_dim, num_class, kernel_size=1) + ) + + def forward(self, conv_out, segSize=None): + conv5 = conv_out[-1] + + input_size = conv5.size() + ppm_out = [conv5] + for pool_scale, pool_conv in zip(self.ppm_pooling, self.ppm_conv): + ppm_out.append(pool_conv(nn.functional.interploate( + pool_scale(conv5), + (input_size[2], input_size[3]), + mode='bilinear', align_corners=False))) + ppm_out = torch.cat(ppm_out, 1) + f = self.ppm_last_conv(ppm_out) + + fpn_feature_list = [f] + for i in reversed(range(len(conv_out) - 1)): + conv_x = conv_out[i] + conv_x = self.fpn_in[i](conv_x) # lateral branch + + f = nn.functional.interpolate( + f, size=conv_x.size()[2:], mode='bilinear', align_corners=False) # top-down branch + f = conv_x + f + + fpn_feature_list.append(self.fpn_out[i](f)) + + fpn_feature_list.reverse() # [P2 - P5] + output_size = fpn_feature_list[0].size()[2:] + fusion_list = [fpn_feature_list[0]] + for i in range(1, len(fpn_feature_list)): + fusion_list.append(nn.functional.interpolate( + fpn_feature_list[i], + output_size, + mode='bilinear', align_corners=False)) + fusion_out = torch.cat(fusion_list, 1) + x = self.conv_last(fusion_out) + + if self.inference or self.use_softmax: # is True during inference + x = nn.functional.interpolate( + x, size=segSize, mode='bilinear', align_corners=False) + if self.use_softmax: + x = nn.functional.softmax(x, dim=1) + return x + + x = nn.functional.log_softmax(x, dim=1) + + return x diff --git a/netdissect/segmodel/object150_info.csv b/netdissect/segmodel/object150_info.csv new file mode 100644 index 0000000000000000000000000000000000000000..8b34d8f3874a38b96894863c5458a7c3c2b0e2e6 --- /dev/null +++ b/netdissect/segmodel/object150_info.csv @@ -0,0 +1,151 @@ +Idx,Ratio,Train,Val,Stuff,Name +1,0.1576,11664,1172,1,wall +2,0.1072,6046,612,1,building;edifice +3,0.0878,8265,796,1,sky +4,0.0621,9336,917,1,floor;flooring +5,0.0480,6678,641,0,tree +6,0.0450,6604,643,1,ceiling +7,0.0398,4023,408,1,road;route +8,0.0231,1906,199,0,bed +9,0.0198,4688,460,0,windowpane;window +10,0.0183,2423,225,1,grass +11,0.0181,2874,294,0,cabinet +12,0.0166,3068,310,1,sidewalk;pavement +13,0.0160,5075,526,0,person;individual;someone;somebody;mortal;soul +14,0.0151,1804,190,1,earth;ground +15,0.0118,6666,796,0,door;double;door +16,0.0110,4269,411,0,table +17,0.0109,1691,160,1,mountain;mount +18,0.0104,3999,441,0,plant;flora;plant;life +19,0.0104,2149,217,0,curtain;drape;drapery;mantle;pall +20,0.0103,3261,318,0,chair +21,0.0098,3164,306,0,car;auto;automobile;machine;motorcar +22,0.0074,709,75,1,water +23,0.0067,3296,315,0,painting;picture +24,0.0065,1191,106,0,sofa;couch;lounge +25,0.0061,1516,162,0,shelf +26,0.0060,667,69,1,house +27,0.0053,651,57,1,sea +28,0.0052,1847,224,0,mirror +29,0.0046,1158,128,1,rug;carpet;carpeting +30,0.0044,480,44,1,field +31,0.0044,1172,98,0,armchair +32,0.0044,1292,184,0,seat +33,0.0033,1386,138,0,fence;fencing +34,0.0031,698,61,0,desk +35,0.0030,781,73,0,rock;stone +36,0.0027,380,43,0,wardrobe;closet;press +37,0.0026,3089,302,0,lamp +38,0.0024,404,37,0,bathtub;bathing;tub;bath;tub +39,0.0024,804,99,0,railing;rail +40,0.0023,1453,153,0,cushion +41,0.0023,411,37,0,base;pedestal;stand +42,0.0022,1440,162,0,box +43,0.0022,800,77,0,column;pillar +44,0.0020,2650,298,0,signboard;sign +45,0.0019,549,46,0,chest;of;drawers;chest;bureau;dresser +46,0.0019,367,36,0,counter +47,0.0018,311,30,1,sand +48,0.0018,1181,122,0,sink +49,0.0018,287,23,1,skyscraper +50,0.0018,468,38,0,fireplace;hearth;open;fireplace +51,0.0018,402,43,0,refrigerator;icebox +52,0.0018,130,12,1,grandstand;covered;stand +53,0.0018,561,64,1,path +54,0.0017,880,102,0,stairs;steps +55,0.0017,86,12,1,runway +56,0.0017,172,11,0,case;display;case;showcase;vitrine +57,0.0017,198,18,0,pool;table;billiard;table;snooker;table +58,0.0017,930,109,0,pillow +59,0.0015,139,18,0,screen;door;screen +60,0.0015,564,52,1,stairway;staircase +61,0.0015,320,26,1,river +62,0.0015,261,29,1,bridge;span +63,0.0014,275,22,0,bookcase +64,0.0014,335,60,0,blind;screen +65,0.0014,792,75,0,coffee;table;cocktail;table +66,0.0014,395,49,0,toilet;can;commode;crapper;pot;potty;stool;throne +67,0.0014,1309,138,0,flower +68,0.0013,1112,113,0,book +69,0.0013,266,27,1,hill +70,0.0013,659,66,0,bench +71,0.0012,331,31,0,countertop +72,0.0012,531,56,0,stove;kitchen;stove;range;kitchen;range;cooking;stove +73,0.0012,369,36,0,palm;palm;tree +74,0.0012,144,9,0,kitchen;island +75,0.0011,265,29,0,computer;computing;machine;computing;device;data;processor;electronic;computer;information;processing;system +76,0.0010,324,33,0,swivel;chair +77,0.0009,304,27,0,boat +78,0.0009,170,20,0,bar +79,0.0009,68,6,0,arcade;machine +80,0.0009,65,8,1,hovel;hut;hutch;shack;shanty +81,0.0009,248,25,0,bus;autobus;coach;charabanc;double-decker;jitney;motorbus;motorcoach;omnibus;passenger;vehicle +82,0.0008,492,49,0,towel +83,0.0008,2510,269,0,light;light;source +84,0.0008,440,39,0,truck;motortruck +85,0.0008,147,18,1,tower +86,0.0008,583,56,0,chandelier;pendant;pendent +87,0.0007,533,61,0,awning;sunshade;sunblind +88,0.0007,1989,239,0,streetlight;street;lamp +89,0.0007,71,5,0,booth;cubicle;stall;kiosk +90,0.0007,618,53,0,television;television;receiver;television;set;tv;tv;set;idiot;box;boob;tube;telly;goggle;box +91,0.0007,135,12,0,airplane;aeroplane;plane +92,0.0007,83,5,1,dirt;track +93,0.0007,178,17,0,apparel;wearing;apparel;dress;clothes +94,0.0006,1003,104,0,pole +95,0.0006,182,12,1,land;ground;soil +96,0.0006,452,50,0,bannister;banister;balustrade;balusters;handrail +97,0.0006,42,6,1,escalator;moving;staircase;moving;stairway +98,0.0006,307,31,0,ottoman;pouf;pouffe;puff;hassock +99,0.0006,965,114,0,bottle +100,0.0006,117,13,0,buffet;counter;sideboard +101,0.0006,354,35,0,poster;posting;placard;notice;bill;card +102,0.0006,108,9,1,stage +103,0.0006,557,55,0,van +104,0.0006,52,4,0,ship +105,0.0005,99,5,0,fountain +106,0.0005,57,4,1,conveyer;belt;conveyor;belt;conveyer;conveyor;transporter +107,0.0005,292,31,0,canopy +108,0.0005,77,9,0,washer;automatic;washer;washing;machine +109,0.0005,340,38,0,plaything;toy +110,0.0005,66,3,1,swimming;pool;swimming;bath;natatorium +111,0.0005,465,49,0,stool +112,0.0005,50,4,0,barrel;cask +113,0.0005,622,75,0,basket;handbasket +114,0.0005,80,9,1,waterfall;falls +115,0.0005,59,3,0,tent;collapsible;shelter +116,0.0005,531,72,0,bag +117,0.0005,282,30,0,minibike;motorbike +118,0.0005,73,7,0,cradle +119,0.0005,435,44,0,oven +120,0.0005,136,25,0,ball +121,0.0005,116,24,0,food;solid;food +122,0.0004,266,31,0,step;stair +123,0.0004,58,12,0,tank;storage;tank +124,0.0004,418,83,0,trade;name;brand;name;brand;marque +125,0.0004,319,43,0,microwave;microwave;oven +126,0.0004,1193,139,0,pot;flowerpot +127,0.0004,97,23,0,animal;animate;being;beast;brute;creature;fauna +128,0.0004,347,36,0,bicycle;bike;wheel;cycle +129,0.0004,52,5,1,lake +130,0.0004,246,22,0,dishwasher;dish;washer;dishwashing;machine +131,0.0004,108,13,0,screen;silver;screen;projection;screen +132,0.0004,201,30,0,blanket;cover +133,0.0004,285,21,0,sculpture +134,0.0004,268,27,0,hood;exhaust;hood +135,0.0003,1020,108,0,sconce +136,0.0003,1282,122,0,vase +137,0.0003,528,65,0,traffic;light;traffic;signal;stoplight +138,0.0003,453,57,0,tray +139,0.0003,671,100,0,ashcan;trash;can;garbage;can;wastebin;ash;bin;ash-bin;ashbin;dustbin;trash;barrel;trash;bin +140,0.0003,397,44,0,fan +141,0.0003,92,8,1,pier;wharf;wharfage;dock +142,0.0003,228,18,0,crt;screen +143,0.0003,570,59,0,plate +144,0.0003,217,22,0,monitor;monitoring;device +145,0.0003,206,19,0,bulletin;board;notice;board +146,0.0003,130,14,0,shower +147,0.0003,178,28,0,radiator +148,0.0002,504,57,0,glass;drinking;glass +149,0.0002,775,96,0,clock +150,0.0002,421,56,0,flag diff --git a/netdissect/segmodel/resnet.py b/netdissect/segmodel/resnet.py new file mode 100644 index 0000000000000000000000000000000000000000..ea5fdf82fafa3058c5f00074d55fbb1e584d5865 --- /dev/null +++ b/netdissect/segmodel/resnet.py @@ -0,0 +1,235 @@ +import os +import sys +import torch +import torch.nn as nn +import math +try: + from lib.nn import SynchronizedBatchNorm2d +except ImportError: + from torch.nn import BatchNorm2d as SynchronizedBatchNorm2d + +try: + from urllib import urlretrieve +except ImportError: + from urllib.request import urlretrieve + + +__all__ = ['ResNet', 'resnet50', 'resnet101'] # resnet101 is coming soon! + + +model_urls = { + 'resnet50': 'http://sceneparsing.csail.mit.edu/model/pretrained_resnet/resnet50-imagenet.pth', + 'resnet101': 'http://sceneparsing.csail.mit.edu/model/pretrained_resnet/resnet101-imagenet.pth' +} + + +def conv3x3(in_planes, out_planes, stride=1): + "3x3 convolution with padding" + return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride, + padding=1, bias=False) + + +class BasicBlock(nn.Module): + expansion = 1 + + def __init__(self, inplanes, planes, stride=1, downsample=None): + super(BasicBlock, self).__init__() + self.conv1 = conv3x3(inplanes, planes, stride) + self.bn1 = SynchronizedBatchNorm2d(planes) + self.relu = nn.ReLU(inplace=True) + self.conv2 = conv3x3(planes, planes) + self.bn2 = SynchronizedBatchNorm2d(planes) + self.downsample = downsample + self.stride = stride + + def forward(self, x): + residual = x + + out = self.conv1(x) + out = self.bn1(out) + out = self.relu(out) + + out = self.conv2(out) + out = self.bn2(out) + + if self.downsample is not None: + residual = self.downsample(x) + + out += residual + out = self.relu(out) + + return out + + +class Bottleneck(nn.Module): + expansion = 4 + + def __init__(self, inplanes, planes, stride=1, downsample=None): + super(Bottleneck, self).__init__() + self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False) + self.bn1 = SynchronizedBatchNorm2d(planes) + self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride, + padding=1, bias=False) + self.bn2 = SynchronizedBatchNorm2d(planes) + self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False) + self.bn3 = SynchronizedBatchNorm2d(planes * 4) + self.relu = nn.ReLU(inplace=True) + self.downsample = downsample + self.stride = stride + + def forward(self, x): + residual = x + + out = self.conv1(x) + out = self.bn1(out) + out = self.relu(out) + + out = self.conv2(out) + out = self.bn2(out) + out = self.relu(out) + + out = self.conv3(out) + out = self.bn3(out) + + if self.downsample is not None: + residual = self.downsample(x) + + out += residual + out = self.relu(out) + + return out + + +class ResNet(nn.Module): + + def __init__(self, block, layers, num_classes=1000): + self.inplanes = 128 + super(ResNet, self).__init__() + self.conv1 = conv3x3(3, 64, stride=2) + self.bn1 = SynchronizedBatchNorm2d(64) + self.relu1 = nn.ReLU(inplace=True) + self.conv2 = conv3x3(64, 64) + self.bn2 = SynchronizedBatchNorm2d(64) + self.relu2 = nn.ReLU(inplace=True) + self.conv3 = conv3x3(64, 128) + self.bn3 = SynchronizedBatchNorm2d(128) + self.relu3 = nn.ReLU(inplace=True) + self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) + + self.layer1 = self._make_layer(block, 64, layers[0]) + self.layer2 = self._make_layer(block, 128, layers[1], stride=2) + self.layer3 = self._make_layer(block, 256, layers[2], stride=2) + self.layer4 = self._make_layer(block, 512, layers[3], stride=2) + self.avgpool = nn.AvgPool2d(7, stride=1) + self.fc = nn.Linear(512 * block.expansion, num_classes) + + for m in self.modules(): + if isinstance(m, nn.Conv2d): + n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels + m.weight.data.normal_(0, math.sqrt(2. / n)) + elif isinstance(m, SynchronizedBatchNorm2d): + m.weight.data.fill_(1) + m.bias.data.zero_() + + def _make_layer(self, block, planes, blocks, stride=1): + downsample = None + if stride != 1 or self.inplanes != planes * block.expansion: + downsample = nn.Sequential( + nn.Conv2d(self.inplanes, planes * block.expansion, + kernel_size=1, stride=stride, bias=False), + SynchronizedBatchNorm2d(planes * block.expansion), + ) + + layers = [] + layers.append(block(self.inplanes, planes, stride, downsample)) + self.inplanes = planes * block.expansion + for i in range(1, blocks): + layers.append(block(self.inplanes, planes)) + + return nn.Sequential(*layers) + + def forward(self, x): + x = self.relu1(self.bn1(self.conv1(x))) + x = self.relu2(self.bn2(self.conv2(x))) + x = self.relu3(self.bn3(self.conv3(x))) + x = self.maxpool(x) + + x = self.layer1(x) + x = self.layer2(x) + x = self.layer3(x) + x = self.layer4(x) + + x = self.avgpool(x) + x = x.view(x.size(0), -1) + x = self.fc(x) + + return x + +''' +def resnet18(pretrained=False, **kwargs): + """Constructs a ResNet-18 model. + + Args: + pretrained (bool): If True, returns a model pre-trained on Places + """ + model = ResNet(BasicBlock, [2, 2, 2, 2], **kwargs) + if pretrained: + model.load_state_dict(load_url(model_urls['resnet18'])) + return model + + +def resnet34(pretrained=False, **kwargs): + """Constructs a ResNet-34 model. + + Args: + pretrained (bool): If True, returns a model pre-trained on Places + """ + model = ResNet(BasicBlock, [3, 4, 6, 3], **kwargs) + if pretrained: + model.load_state_dict(load_url(model_urls['resnet34'])) + return model +''' + +def resnet50(pretrained=False, **kwargs): + """Constructs a ResNet-50 model. + + Args: + pretrained (bool): If True, returns a model pre-trained on Places + """ + model = ResNet(Bottleneck, [3, 4, 6, 3], **kwargs) + if pretrained: + model.load_state_dict(load_url(model_urls['resnet50']), strict=False) + return model + + +def resnet101(pretrained=False, **kwargs): + """Constructs a ResNet-101 model. + + Args: + pretrained (bool): If True, returns a model pre-trained on Places + """ + model = ResNet(Bottleneck, [3, 4, 23, 3], **kwargs) + if pretrained: + model.load_state_dict(load_url(model_urls['resnet101']), strict=False) + return model + +# def resnet152(pretrained=False, **kwargs): +# """Constructs a ResNet-152 model. +# +# Args: +# pretrained (bool): If True, returns a model pre-trained on Places +# """ +# model = ResNet(Bottleneck, [3, 8, 36, 3], **kwargs) +# if pretrained: +# model.load_state_dict(load_url(model_urls['resnet152'])) +# return model + +def load_url(url, model_dir='./pretrained', map_location=None): + if not os.path.exists(model_dir): + os.makedirs(model_dir) + filename = url.split('/')[-1] + cached_file = os.path.join(model_dir, filename) + if not os.path.exists(cached_file): + sys.stderr.write('Downloading: "{}" to {}\n'.format(url, cached_file)) + urlretrieve(url, cached_file) + return torch.load(cached_file, map_location=map_location) diff --git a/netdissect/segmodel/resnext.py b/netdissect/segmodel/resnext.py new file mode 100644 index 0000000000000000000000000000000000000000..cdbb7461a6c8eb126717967cdca5d5ce392aecea --- /dev/null +++ b/netdissect/segmodel/resnext.py @@ -0,0 +1,182 @@ +import os +import sys +import torch +import torch.nn as nn +import math +try: + from lib.nn import SynchronizedBatchNorm2d +except ImportError: + from torch.nn import BatchNorm2d as SynchronizedBatchNorm2d +try: + from urllib import urlretrieve +except ImportError: + from urllib.request import urlretrieve + + +__all__ = ['ResNeXt', 'resnext101'] # support resnext 101 + + +model_urls = { + #'resnext50': 'http://sceneparsing.csail.mit.edu/model/pretrained_resnet/resnext50-imagenet.pth', + 'resnext101': 'http://sceneparsing.csail.mit.edu/model/pretrained_resnet/resnext101-imagenet.pth' +} + + +def conv3x3(in_planes, out_planes, stride=1): + "3x3 convolution with padding" + return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride, + padding=1, bias=False) + + +class GroupBottleneck(nn.Module): + expansion = 2 + + def __init__(self, inplanes, planes, stride=1, groups=1, downsample=None): + super(GroupBottleneck, self).__init__() + self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False) + self.bn1 = SynchronizedBatchNorm2d(planes) + self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride, + padding=1, groups=groups, bias=False) + self.bn2 = SynchronizedBatchNorm2d(planes) + self.conv3 = nn.Conv2d(planes, planes * 2, kernel_size=1, bias=False) + self.bn3 = SynchronizedBatchNorm2d(planes * 2) + self.relu = nn.ReLU(inplace=True) + self.downsample = downsample + self.stride = stride + + def forward(self, x): + residual = x + + out = self.conv1(x) + out = self.bn1(out) + out = self.relu(out) + + out = self.conv2(out) + out = self.bn2(out) + out = self.relu(out) + + out = self.conv3(out) + out = self.bn3(out) + + if self.downsample is not None: + residual = self.downsample(x) + + out += residual + out = self.relu(out) + + return out + + +class ResNeXt(nn.Module): + + def __init__(self, block, layers, groups=32, num_classes=1000): + self.inplanes = 128 + super(ResNeXt, self).__init__() + self.conv1 = conv3x3(3, 64, stride=2) + self.bn1 = SynchronizedBatchNorm2d(64) + self.relu1 = nn.ReLU(inplace=True) + self.conv2 = conv3x3(64, 64) + self.bn2 = SynchronizedBatchNorm2d(64) + self.relu2 = nn.ReLU(inplace=True) + self.conv3 = conv3x3(64, 128) + self.bn3 = SynchronizedBatchNorm2d(128) + self.relu3 = nn.ReLU(inplace=True) + self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) + + self.layer1 = self._make_layer(block, 128, layers[0], groups=groups) + self.layer2 = self._make_layer(block, 256, layers[1], stride=2, groups=groups) + self.layer3 = self._make_layer(block, 512, layers[2], stride=2, groups=groups) + self.layer4 = self._make_layer(block, 1024, layers[3], stride=2, groups=groups) + self.avgpool = nn.AvgPool2d(7, stride=1) + self.fc = nn.Linear(1024 * block.expansion, num_classes) + + for m in self.modules(): + if isinstance(m, nn.Conv2d): + n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels // m.groups + m.weight.data.normal_(0, math.sqrt(2. / n)) + elif isinstance(m, SynchronizedBatchNorm2d): + m.weight.data.fill_(1) + m.bias.data.zero_() + + def _make_layer(self, block, planes, blocks, stride=1, groups=1): + downsample = None + if stride != 1 or self.inplanes != planes * block.expansion: + downsample = nn.Sequential( + nn.Conv2d(self.inplanes, planes * block.expansion, + kernel_size=1, stride=stride, bias=False), + SynchronizedBatchNorm2d(planes * block.expansion), + ) + + layers = [] + layers.append(block(self.inplanes, planes, stride, groups, downsample)) + self.inplanes = planes * block.expansion + for i in range(1, blocks): + layers.append(block(self.inplanes, planes, groups=groups)) + + return nn.Sequential(*layers) + + def forward(self, x): + x = self.relu1(self.bn1(self.conv1(x))) + x = self.relu2(self.bn2(self.conv2(x))) + x = self.relu3(self.bn3(self.conv3(x))) + x = self.maxpool(x) + + x = self.layer1(x) + x = self.layer2(x) + x = self.layer3(x) + x = self.layer4(x) + + x = self.avgpool(x) + x = x.view(x.size(0), -1) + x = self.fc(x) + + return x + + +''' +def resnext50(pretrained=False, **kwargs): + """Constructs a ResNet-50 model. + + Args: + pretrained (bool): If True, returns a model pre-trained on Places + """ + model = ResNeXt(GroupBottleneck, [3, 4, 6, 3], **kwargs) + if pretrained: + model.load_state_dict(load_url(model_urls['resnext50']), strict=False) + return model +''' + + +def resnext101(pretrained=False, **kwargs): + """Constructs a ResNet-101 model. + + Args: + pretrained (bool): If True, returns a model pre-trained on Places + """ + model = ResNeXt(GroupBottleneck, [3, 4, 23, 3], **kwargs) + if pretrained: + model.load_state_dict(load_url(model_urls['resnext101']), strict=False) + return model + + +# def resnext152(pretrained=False, **kwargs): +# """Constructs a ResNeXt-152 model. +# +# Args: +# pretrained (bool): If True, returns a model pre-trained on Places +# """ +# model = ResNeXt(GroupBottleneck, [3, 8, 36, 3], **kwargs) +# if pretrained: +# model.load_state_dict(load_url(model_urls['resnext152'])) +# return model + + +def load_url(url, model_dir='./pretrained', map_location=None): + if not os.path.exists(model_dir): + os.makedirs(model_dir) + filename = url.split('/')[-1] + cached_file = os.path.join(model_dir, filename) + if not os.path.exists(cached_file): + sys.stderr.write('Downloading: "{}" to {}\n'.format(url, cached_file)) + urlretrieve(url, cached_file) + return torch.load(cached_file, map_location=map_location) diff --git a/netdissect/segviz.py b/netdissect/segviz.py new file mode 100644 index 0000000000000000000000000000000000000000..3bb954317aaf0fd6e31b6216cc7a59f01a5fb0bd --- /dev/null +++ b/netdissect/segviz.py @@ -0,0 +1,283 @@ +import numpy, scipy + +def segment_visualization(seg, size): + result = numpy.zeros((seg.shape[1] * seg.shape[2], 3), dtype=numpy.uint8) + flatseg = seg.reshape(seg.shape[0], seg.shape[1] * seg.shape[2]) + bc = numpy.bincount(flatseg.flatten()) + top = numpy.argsort(-bc) + # In a multilabel segmentation, we can't draw everything. + # Draw the fewest-pixel labels last. (We could pick the opposite order.) + for label in top: + if label == 0: + continue + if bc[label] == 0: + break + bitmap = ((flatseg == label).sum(axis=0) > 0) + result[bitmap] = high_contrast_arr[label % len(high_contrast_arr)] + result = result.reshape((seg.shape[1], seg.shape[2], 3)) + if seg.shape[1:] != size: + result = scipy.misc.imresize(result, size, interp='nearest') + return result + +# A palette that maximizes perceptual contrast between entries. +# https://stackoverflow.com/questions/33295120 +high_contrast = [ + [0, 0, 0], [255, 255, 0], [28, 230, 255], [255, 52, 255], + [255, 74, 70], [0, 137, 65], [0, 111, 166], [163, 0, 89], + [255, 219, 229], [122, 73, 0], [0, 0, 166], [99, 255, 172], + [183, 151, 98], [0, 77, 67], [143, 176, 255], [153, 125, 135], + [90, 0, 7], [128, 150, 147], [254, 255, 230], [27, 68, 0], + [79, 198, 1], [59, 93, 255], [74, 59, 83], [255, 47, 128], + [97, 97, 90], [186, 9, 0], [107, 121, 0], [0, 194, 160], + [255, 170, 146], [255, 144, 201], [185, 3, 170], [209, 97, 0], + [221, 239, 255], [0, 0, 53], [123, 79, 75], [161, 194, 153], + [48, 0, 24], [10, 166, 216], [1, 51, 73], [0, 132, 111], + [55, 33, 1], [255, 181, 0], [194, 255, 237], [160, 121, 191], + [204, 7, 68], [192, 185, 178], [194, 255, 153], [0, 30, 9], + [0, 72, 156], [111, 0, 98], [12, 189, 102], [238, 195, 255], + [69, 109, 117], [183, 123, 104], [122, 135, 161], [120, 141, 102], + [136, 85, 120], [250, 208, 159], [255, 138, 154], [209, 87, 160], + [190, 196, 89], [69, 102, 72], [0, 134, 237], [136, 111, 76], + [52, 54, 45], [180, 168, 189], [0, 166, 170], [69, 44, 44], + [99, 99, 117], [163, 200, 201], [255, 145, 63], [147, 138, 129], + [87, 83, 41], [0, 254, 207], [176, 91, 111], [140, 208, 255], + [59, 151, 0], [4, 247, 87], [200, 161, 161], [30, 110, 0], + [121, 0, 215], [167, 117, 0], [99, 103, 169], [160, 88, 55], + [107, 0, 44], [119, 38, 0], [215, 144, 255], [155, 151, 0], + [84, 158, 121], [255, 246, 159], [32, 22, 37], [114, 65, 143], + [188, 35, 255], [153, 173, 192], [58, 36, 101], [146, 35, 41], + [91, 69, 52], [253, 232, 220], [64, 78, 85], [0, 137, 163], + [203, 126, 152], [164, 232, 4], [50, 78, 114], [106, 58, 76], + [131, 171, 88], [0, 28, 30], [209, 247, 206], [0, 75, 40], + [200, 208, 246], [163, 164, 137], [128, 108, 102], [34, 40, 0], + [191, 86, 80], [232, 48, 0], [102, 121, 109], [218, 0, 124], + [255, 26, 89], [138, 219, 180], [30, 2, 0], [91, 78, 81], + [200, 149, 197], [50, 0, 51], [255, 104, 50], [102, 225, 211], + [207, 205, 172], [208, 172, 148], [126, 211, 121], [1, 44, 88], + [122, 123, 255], [214, 142, 1], [53, 51, 57], [120, 175, 161], + [254, 178, 198], [117, 121, 124], [131, 115, 147], [148, 58, 77], + [181, 244, 255], [210, 220, 213], [149, 86, 189], [106, 113, 74], + [0, 19, 37], [2, 82, 95], [10, 163, 247], [233, 129, 118], + [219, 213, 221], [94, 188, 209], [61, 79, 68], [126, 100, 5], + [2, 104, 78], [150, 43, 117], [141, 133, 70], [150, 149, 197], + [231, 115, 206], [216, 106, 120], [62, 137, 190], [202, 131, 78], + [81, 138, 135], [91, 17, 60], [85, 129, 59], [231, 4, 196], + [0, 0, 95], [169, 115, 153], [75, 129, 96], [89, 115, 138], + [255, 93, 167], [247, 201, 191], [100, 49, 39], [81, 58, 1], + [107, 148, 170], [81, 160, 88], [164, 91, 2], [29, 23, 2], + [226, 0, 39], [231, 171, 99], [76, 96, 1], [156, 105, 102], + [100, 84, 123], [151, 151, 158], [0, 106, 102], [57, 20, 6], + [244, 215, 73], [0, 69, 210], [0, 108, 49], [221, 182, 208], + [124, 101, 113], [159, 178, 164], [0, 216, 145], [21, 160, 138], + [188, 101, 233], [255, 255, 254], [198, 220, 153], [32, 59, 60], + [103, 17, 144], [107, 58, 100], [245, 225, 255], [255, 160, 242], + [204, 170, 53], [55, 69, 39], [139, 180, 0], [121, 120, 104], + [198, 0, 90], [59, 0, 10], [200, 98, 64], [41, 96, 124], + [64, 35, 52], [125, 90, 68], [204, 184, 124], [184, 129, 131], + [170, 81, 153], [181, 214, 195], [163, 132, 105], [159, 148, 240], + [167, 69, 113], [184, 148, 166], [113, 187, 140], [0, 180, 51], + [120, 158, 201], [109, 128, 186], [149, 63, 0], [94, 255, 3], + [228, 255, 252], [27, 225, 119], [188, 177, 229], [118, 145, 47], + [0, 49, 9], [0, 96, 205], [210, 0, 150], [137, 85, 99], + [41, 32, 29], [91, 50, 19], [167, 111, 66], [137, 65, 46], + [26, 58, 42], [73, 75, 90], [168, 140, 133], [244, 171, 170], + [163, 243, 171], [0, 198, 200], [234, 139, 102], [149, 138, 159], + [189, 201, 210], [159, 160, 100], [190, 71, 0], [101, 129, 136], + [131, 164, 133], [69, 60, 35], [71, 103, 93], [58, 63, 0], + [6, 18, 3], [223, 251, 113], [134, 142, 126], [152, 208, 88], + [108, 143, 125], [215, 191, 194], [60, 62, 110], [216, 61, 102], + [47, 93, 155], [108, 94, 70], [210, 91, 136], [91, 101, 108], + [0, 181, 127], [84, 92, 70], [134, 96, 151], [54, 93, 37], + [37, 47, 153], [0, 204, 255], [103, 78, 96], [252, 0, 156], + [146, 137, 107], [30, 35, 36], [222, 201, 178], [157, 73, 72], + [133, 171, 180], [52, 33, 66], [208, 150, 133], [164, 172, 172], + [0, 255, 255], [174, 156, 134], [116, 42, 51], [14, 114, 197], + [175, 216, 236], [192, 100, 185], [145, 2, 140], [254, 237, 191], + [255, 183, 137], [156, 184, 228], [175, 255, 209], [42, 54, 76], + [79, 74, 67], [100, 112, 149], [52, 187, 255], [128, 119, 129], + [146, 0, 3], [179, 165, 167], [1, 134, 21], [241, 255, 200], + [151, 111, 92], [255, 59, 193], [255, 95, 107], [7, 125, 132], + [245, 109, 147], [87, 113, 218], [78, 30, 42], [131, 0, 85], + [2, 211, 70], [190, 69, 45], [0, 144, 94], [190, 0, 40], + [110, 150, 227], [0, 118, 153], [254, 201, 109], [156, 106, 125], + [63, 161, 184], [137, 61, 227], [121, 180, 214], [127, 212, 217], + [103, 81, 187], [178, 141, 45], [226, 122, 5], [221, 156, 184], + [170, 188, 122], [152, 0, 52], [86, 26, 2], [143, 127, 0], + [99, 80, 0], [205, 125, 174], [138, 94, 45], [255, 179, 225], + [107, 100, 102], [198, 211, 0], [1, 0, 226], [136, 236, 105], + [143, 204, 190], [33, 0, 28], [81, 31, 77], [227, 246, 227], + [255, 142, 177], [107, 79, 41], [163, 127, 70], [106, 89, 80], + [31, 42, 26], [4, 120, 77], [16, 24, 53], [230, 224, 208], + [255, 116, 254], [0, 164, 95], [143, 93, 248], [75, 0, 89], + [65, 47, 35], [216, 147, 158], [219, 157, 114], [96, 65, 67], + [181, 186, 206], [152, 158, 183], [210, 196, 219], [165, 135, 175], + [119, 215, 150], [127, 140, 148], [255, 155, 3], [85, 81, 150], + [49, 221, 174], [116, 182, 113], [128, 38, 71], [42, 55, 63], + [1, 74, 104], [105, 102, 40], [76, 123, 109], [0, 44, 39], + [122, 69, 34], [59, 88, 89], [229, 211, 129], [255, 243, 255], + [103, 159, 160], [38, 19, 0], [44, 87, 66], [145, 49, 175], + [175, 93, 136], [199, 112, 106], [97, 171, 31], [140, 242, 212], + [197, 217, 184], [159, 255, 251], [191, 69, 204], [73, 57, 65], + [134, 59, 96], [185, 0, 118], [0, 49, 119], [197, 130, 210], + [193, 179, 148], [96, 43, 112], [136, 120, 104], [186, 191, 176], + [3, 0, 18], [209, 172, 254], [127, 222, 254], [75, 92, 113], + [163, 160, 151], [230, 109, 83], [99, 123, 93], [146, 190, 165], + [0, 248, 179], [190, 221, 255], [61, 181, 167], [221, 50, 72], + [182, 228, 222], [66, 119, 69], [89, 140, 90], [185, 76, 89], + [129, 129, 213], [148, 136, 139], [254, 214, 189], [83, 109, 49], + [110, 255, 146], [228, 232, 255], [32, 226, 0], [255, 208, 242], + [76, 131, 161], [189, 115, 34], [145, 92, 78], [140, 71, 135], + [2, 81, 23], [162, 170, 69], [45, 27, 33], [169, 221, 176], + [255, 79, 120], [82, 133, 0], [0, 154, 46], [23, 252, 228], + [113, 85, 90], [82, 93, 130], [0, 25, 90], [150, 120, 116], + [85, 85, 88], [11, 33, 44], [30, 32, 43], [239, 191, 196], + [111, 151, 85], [111, 117, 134], [80, 29, 29], [55, 45, 0], + [116, 29, 22], [94, 179, 147], [181, 180, 0], [221, 74, 56], + [54, 61, 255], [173, 101, 82], [102, 53, 175], [131, 107, 186], + [152, 170, 127], [70, 72, 54], [50, 44, 62], [124, 185, 186], + [91, 105, 101], [112, 125, 61], [122, 0, 29], [110, 70, 54], + [68, 58, 56], [174, 129, 255], [72, 144, 121], [137, 115, 52], + [0, 144, 135], [218, 113, 60], [54, 22, 24], [255, 111, 1], + [0, 102, 121], [55, 14, 119], [75, 58, 131], [201, 226, 230], + [196, 65, 112], [255, 69, 38], [115, 190, 84], [196, 223, 114], + [173, 255, 96], [0, 68, 125], [220, 206, 201], [189, 148, 121], + [101, 110, 91], [236, 82, 0], [255, 110, 194], [122, 97, 126], + [221, 174, 162], [119, 131, 127], [165, 51, 39], [96, 142, 255], + [181, 153, 215], [165, 1, 73], [78, 0, 37], [201, 177, 169], + [3, 145, 154], [27, 42, 37], [229, 0, 241], [152, 46, 11], + [182, 113, 128], [224, 88, 89], [0, 96, 57], [87, 143, 155], + [48, 82, 48], [206, 147, 76], [179, 194, 190], [192, 186, 192], + [181, 6, 211], [23, 12, 16], [76, 83, 79], [34, 68, 81], + [62, 65, 65], [120, 114, 109], [182, 96, 43], [32, 4, 65], + [221, 181, 136], [73, 114, 0], [197, 170, 182], [3, 60, 97], + [113, 178, 245], [169, 224, 136], [73, 121, 176], [162, 195, 223], + [120, 65, 73], [45, 43, 23], [62, 14, 47], [87, 52, 76], + [0, 145, 190], [228, 81, 209], [75, 75, 106], [92, 1, 26], + [124, 128, 96], [255, 148, 145], [76, 50, 93], [0, 92, 139], + [229, 253, 164], [104, 209, 182], [3, 38, 65], [20, 0, 35], + [134, 131, 169], [207, 255, 0], [167, 44, 62], [52, 71, 90], + [177, 187, 154], [180, 160, 79], [141, 145, 142], [161, 104, 166], + [129, 61, 58], [66, 82, 24], [218, 131, 134], [119, 97, 51], + [86, 57, 48], [132, 152, 174], [144, 193, 211], [181, 102, 107], + [155, 88, 94], [133, 100, 101], [173, 124, 144], [226, 188, 0], + [227, 170, 224], [178, 194, 254], [253, 0, 57], [0, 155, 117], + [255, 244, 109], [232, 126, 172], [223, 227, 230], [132, 133, 144], + [170, 146, 151], [131, 161, 147], [87, 121, 119], [62, 113, 88], + [198, 66, 137], [234, 0, 114], [196, 168, 203], [85, 200, 153], + [231, 143, 207], [0, 69, 71], [246, 226, 227], [150, 103, 22], + [55, 143, 219], [67, 94, 106], [218, 0, 4], [27, 0, 15], + [91, 156, 143], [110, 43, 82], [1, 17, 21], [227, 232, 196], + [174, 59, 133], [234, 28, 169], [255, 158, 107], [69, 125, 139], + [146, 103, 139], [0, 205, 187], [156, 204, 4], [0, 46, 56], + [150, 197, 127], [207, 246, 180], [73, 40, 24], [118, 110, 82], + [32, 55, 14], [227, 209, 159], [46, 60, 48], [178, 234, 206], + [243, 189, 164], [162, 78, 61], [151, 111, 217], [140, 159, 168], + [124, 43, 115], [78, 95, 55], [93, 84, 98], [144, 149, 111], + [106, 167, 118], [219, 203, 246], [218, 113, 255], [152, 124, 149], + [82, 50, 60], [187, 60, 66], [88, 77, 57], [79, 193, 95], + [162, 185, 193], [121, 219, 33], [29, 89, 88], [189, 116, 78], + [22, 11, 0], [32, 34, 26], [107, 130, 149], [0, 224, 228], + [16, 36, 1], [27, 120, 42], [218, 169, 181], [176, 65, 93], + [133, 146, 83], [151, 160, 148], [6, 227, 196], [71, 104, 140], + [124, 103, 85], [7, 92, 0], [117, 96, 213], [125, 159, 0], + [195, 109, 150], [77, 145, 62], [95, 66, 118], [252, 228, 200], + [48, 48, 82], [79, 56, 27], [229, 165, 50], [112, 102, 144], + [170, 154, 146], [35, 115, 99], [115, 1, 62], [255, 144, 121], + [167, 154, 116], [2, 155, 219], [255, 1, 105], [199, 210, 231], + [202, 136, 105], [128, 255, 205], [187, 31, 105], [144, 176, 171], + [125, 116, 169], [252, 199, 219], [153, 55, 91], [0, 171, 77], + [171, 174, 209], [190, 157, 145], [230, 229, 167], [51, 44, 34], + [221, 88, 123], [245, 255, 247], [93, 48, 51], [109, 56, 0], + [255, 0, 32], [181, 123, 179], [215, 255, 230], [197, 53, 169], + [38, 0, 9], [106, 135, 129], [168, 171, 180], [212, 82, 98], + [121, 75, 97], [70, 33, 178], [141, 164, 219], [199, 200, 144], + [111, 233, 173], [162, 67, 167], [178, 176, 129], [24, 27, 0], + [40, 97, 84], [76, 164, 59], [106, 149, 115], [168, 68, 29], + [92, 114, 123], [115, 134, 113], [208, 207, 203], [137, 123, 119], + [31, 63, 34], [65, 69, 167], [218, 152, 148], [161, 117, 122], + [99, 36, 60], [173, 170, 255], [0, 205, 226], [221, 188, 98], + [105, 142, 177], [32, 132, 98], [0, 183, 224], [97, 74, 68], + [155, 187, 87], [122, 92, 84], [133, 122, 80], [118, 107, 126], + [1, 72, 51], [255, 131, 71], [122, 142, 186], [39, 71, 64], + [148, 100, 68], [235, 216, 230], [100, 98, 65], [55, 57, 23], + [106, 212, 80], [129, 129, 123], [212, 153, 227], [151, 148, 64], + [1, 26, 18], [82, 101, 84], [181, 136, 92], [164, 153, 165], + [3, 173, 137], [179, 0, 139], [227, 196, 181], [150, 83, 31], + [134, 113, 117], [116, 86, 158], [97, 125, 159], [231, 4, 82], + [6, 126, 175], [166, 151, 182], [183, 135, 168], [156, 255, 147], + [49, 29, 25], [58, 148, 89], [110, 116, 110], [176, 197, 174], + [132, 237, 247], [237, 52, 136], [117, 76, 120], [56, 70, 68], + [199, 132, 123], [0, 182, 197], [127, 166, 112], [193, 175, 158], + [42, 127, 255], [114, 165, 140], [255, 192, 127], [157, 235, 221], + [217, 124, 142], [126, 124, 147], [98, 230, 116], [181, 99, 158], + [255, 168, 97], [194, 165, 128], [141, 156, 131], [183, 5, 70], + [55, 43, 46], [0, 152, 255], [152, 89, 117], [32, 32, 76], + [255, 108, 96], [68, 80, 131], [133, 2, 170], [114, 54, 31], + [150, 118, 163], [72, 68, 73], [206, 214, 194], [59, 22, 74], + [204, 167, 99], [44, 127, 119], [2, 34, 123], [163, 126, 111], + [205, 230, 220], [205, 255, 251], [190, 129, 26], [247, 113, 131], + [237, 230, 226], [205, 198, 180], [255, 224, 158], [58, 114, 113], + [255, 123, 89], [78, 78, 1], [74, 198, 132], [139, 200, 145], + [188, 138, 150], [207, 99, 83], [220, 222, 92], [94, 170, 221], + [246, 160, 173], [226, 105, 170], [163, 218, 228], [67, 110, 131], + [0, 46, 23], [236, 251, 255], [161, 194, 182], [80, 0, 63], + [113, 105, 91], [103, 196, 187], [83, 110, 255], [93, 90, 72], + [137, 0, 57], [150, 147, 129], [55, 21, 33], [94, 70, 101], + [170, 98, 195], [141, 111, 129], [44, 97, 53], [65, 6, 1], + [86, 70, 32], [230, 144, 52], [109, 166, 189], [229, 142, 86], + [227, 166, 139], [72, 177, 118], [210, 125, 103], [181, 178, 104], + [127, 132, 39], [255, 132, 230], [67, 87, 64], [234, 228, 8], + [244, 245, 255], [50, 88, 0], [75, 107, 165], [173, 206, 255], + [155, 138, 204], [136, 81, 56], [88, 117, 193], [126, 115, 17], + [254, 165, 202], [159, 139, 91], [165, 91, 84], [137, 0, 106], + [175, 117, 111], [42, 32, 0], [116, 153, 161], [255, 181, 80], + [0, 1, 30], [209, 81, 28], [104, 129, 81], [188, 144, 138], + [120, 200, 235], [133, 2, 255], [72, 61, 48], [196, 34, 33], + [94, 167, 255], [120, 87, 21], [12, 234, 145], [255, 250, 237], + [179, 175, 157], [62, 61, 82], [90, 155, 194], [156, 47, 144], + [141, 87, 0], [173, 215, 156], [0, 118, 139], [51, 125, 0], + [197, 151, 0], [49, 86, 220], [148, 69, 117], [236, 255, 220], + [210, 76, 178], [151, 112, 60], [76, 37, 127], [158, 3, 102], + [136, 255, 236], [181, 100, 129], [57, 109, 43], [86, 115, 95], + [152, 131, 118], [155, 177, 149], [169, 121, 92], [228, 197, 211], + [159, 79, 103], [30, 43, 57], [102, 67, 39], [175, 206, 120], + [50, 46, 223], [134, 180, 135], [194, 48, 0], [171, 232, 107], + [150, 101, 109], [37, 14, 53], [166, 0, 25], [0, 128, 207], + [202, 239, 255], [50, 63, 97], [164, 73, 220], [106, 157, 59], + [255, 90, 228], [99, 106, 1], [209, 108, 218], [115, 96, 96], + [255, 186, 173], [211, 105, 180], [255, 222, 214], [108, 109, 116], + [146, 125, 94], [132, 93, 112], [91, 98, 193], [47, 74, 54], + [228, 95, 53], [255, 59, 83], [172, 132, 221], [118, 41, 136], + [112, 236, 152], [64, 133, 67], [44, 53, 51], [46, 24, 45], + [50, 57, 37], [25, 24, 27], [47, 46, 44], [2, 60, 50], + [155, 158, 226], [88, 175, 173], [92, 66, 77], [122, 197, 166], + [104, 93, 117], [185, 188, 189], [131, 67, 87], [26, 123, 66], + [46, 87, 170], [229, 81, 153], [49, 110, 71], [205, 0, 197], + [106, 0, 77], [127, 187, 236], [243, 86, 145], [215, 197, 74], + [98, 172, 183], [203, 161, 188], [162, 138, 154], [108, 63, 59], + [255, 228, 125], [220, 186, 227], [95, 129, 109], [58, 64, 74], + [125, 191, 50], [230, 236, 220], [133, 44, 25], [40, 83, 102], + [184, 203, 156], [14, 13, 0], [75, 93, 86], [107, 84, 63], + [226, 113, 114], [5, 104, 236], [46, 181, 0], [210, 22, 86], + [239, 175, 255], [104, 32, 33], [45, 32, 17], [218, 76, 255], + [112, 150, 142], [255, 123, 125], [74, 25, 48], [232, 194, 130], + [231, 219, 188], [166, 132, 134], [31, 38, 60], [54, 87, 78], + [82, 206, 121], [173, 170, 169], [138, 159, 69], [101, 66, 210], + [0, 251, 140], [93, 105, 123], [204, 210, 127], [148, 165, 161], + [121, 2, 41], [227, 131, 230], [126, 164, 193], [78, 68, 82], + [75, 44, 0], [98, 11, 112], [49, 76, 30], [135, 74, 166], + [227, 0, 145], [102, 70, 10], [235, 154, 139], [234, 195, 163], + [152, 234, 179], [171, 145, 128], [184, 85, 47], [26, 43, 47], + [148, 221, 197], [157, 140, 118], [156, 131, 51], [148, 169, 201], + [57, 41, 53], [140, 103, 94], [204, 233, 58], [145, 113, 0], + [1, 64, 11], [68, 152, 150], [28, 163, 112], [224, 141, 167], + [139, 74, 78], [102, 119, 118], [70, 146, 173], [103, 189, 168], + [105, 37, 92], [211, 191, 255], [74, 81, 50], [126, 146, 133], + [119, 115, 60], [231, 160, 204], [81, 162, 136], [44, 101, 106], + [77, 92, 94], [201, 64, 58], [221, 215, 243], [0, 88, 68], + [180, 162, 0], [72, 143, 105], [133, 129, 130], [212, 233, 185], + [61, 115, 151], [202, 232, 206], [214, 0, 52], [170, 103, 70], + [158, 85, 133], [186, 98, 0] +] + +high_contrast_arr = numpy.array(high_contrast, dtype=numpy.uint8) diff --git a/netdissect/server.py b/netdissect/server.py new file mode 100644 index 0000000000000000000000000000000000000000..d8422a2bad5ac2a09d4582a98da4f962dac1a911 --- /dev/null +++ b/netdissect/server.py @@ -0,0 +1,185 @@ +#!/usr/bin/env python + +import argparse, connexion, os, sys, yaml, json, socket +from netdissect.easydict import EasyDict +from flask import send_from_directory, redirect +from flask_cors import CORS + + +from netdissect.serverstate import DissectionProject + +__author__ = 'Hendrik Strobelt, David Bau' + +CONFIG_FILE_NAME = 'dissect.json' +projects = {} + +app = connexion.App(__name__, debug=False) + + +def get_all_projects(): + res = [] + for key, project in projects.items(): + # print key + res.append({ + 'project': key, + 'info': { + 'layers': [layer['layer'] for layer in project.get_layers()] + } + }) + return sorted(res, key=lambda x: x['project']) + +def get_layers(project): + return { + 'request': {'project': project}, + 'res': projects[project].get_layers() + } + +def get_units(project, layer): + return { + 'request': {'project': project, 'layer': layer}, + 'res': projects[project].get_units(layer) + } + +def get_rankings(project, layer): + return { + 'request': {'project': project, 'layer': layer}, + 'res': projects[project].get_rankings(layer) + } + +def get_levels(project, layer, quantiles): + return { + 'request': {'project': project, 'layer': layer, 'quantiles': quantiles}, + 'res': projects[project].get_levels(layer, quantiles) + } + +def get_channels(project, layer): + answer = dict(channels=projects[project].get_channels(layer)) + return { + 'request': {'project': project, 'layer': layer}, + 'res': answer + } + +def post_generate(gen_req): + project = gen_req['project'] + zs = gen_req.get('zs', None) + ids = gen_req.get('ids', None) + return_urls = gen_req.get('return_urls', False) + assert (zs is None) != (ids is None) # one or the other, not both + ablations = gen_req.get('ablations', []) + interventions = gen_req.get('interventions', None) + # no z avilable if ablations + generated = projects[project].generate_images(zs, ids, interventions, + return_urls=return_urls) + return { + 'request': gen_req, + 'res': generated + } + +def post_features(feat_req): + project = feat_req['project'] + ids = feat_req['ids'] + masks = feat_req.get('masks', None) + layers = feat_req.get('layers', None) + interventions = feat_req.get('interventions', None) + features = projects[project].get_features( + ids, masks, layers, interventions) + return { + 'request': feat_req, + 'res': features + } + +def post_featuremaps(feat_req): + project = feat_req['project'] + ids = feat_req['ids'] + layers = feat_req.get('layers', None) + interventions = feat_req.get('interventions', None) + featuremaps = projects[project].get_featuremaps( + ids, layers, interventions) + return { + 'request': feat_req, + 'res': featuremaps + } + +@app.route('/client/') +def send_static(path): + """ serves all files from ./client/ to ``/client/`` + + :param path: path from api call + """ + return send_from_directory(args.client, path) + +@app.route('/data/') +def send_data(path): + """ serves all files from the data dir to ``/dissect/`` + + :param path: path from api call + """ + print('Got the data route for', path) + return send_from_directory(args.data, path) + + +@app.route('/') +def redirect_home(): + return redirect('/client/index.html', code=302) + + +def load_projects(directory): + """ + searches for CONFIG_FILE_NAME in all subdirectories of directory + and creates data handlers for all of them + + :param directory: scan directory + :return: null + """ + project_dirs = [] + # Don't search more than 2 dirs deep. + search_depth = 2 + directory.count(os.path.sep) + for root, dirs, files in os.walk(directory): + if CONFIG_FILE_NAME in files: + project_dirs.append(root) + # Don't get subprojects under a project dir. + del dirs[:] + elif root.count(os.path.sep) >= search_depth: + del dirs[:] + for p_dir in project_dirs: + print('Loading %s' % os.path.join(p_dir, CONFIG_FILE_NAME)) + with open(os.path.join(p_dir, CONFIG_FILE_NAME), 'r') as jf: + config = EasyDict(json.load(jf)) + dh_id = os.path.split(p_dir)[1] + projects[dh_id] = DissectionProject( + config=config, + project_dir=p_dir, + path_url='data/' + os.path.relpath(p_dir, directory), + public_host=args.public_host) + +app.add_api('server.yaml') + +# add CORS support +CORS(app.app, headers='Content-Type') + +parser = argparse.ArgumentParser() +parser.add_argument("--nodebug", default=False) +parser.add_argument("--address", default="127.0.0.1") # 0.0.0.0 for nonlocal use +parser.add_argument("--port", default="5001") +parser.add_argument("--public_host", default=None) +parser.add_argument("--nocache", default=False) +parser.add_argument("--data", type=str, default='dissect') +parser.add_argument("--client", type=str, default='client_dist') + +if __name__ == '__main__': + args = parser.parse_args() + for d in [args.data, args.client]: + if not os.path.isdir(d): + print('No directory %s' % d) + sys.exit(1) + args.data = os.path.abspath(args.data) + args.client = os.path.abspath(args.client) + if args.public_host is None: + args.public_host = '%s:%d' % (socket.getfqdn(), int(args.port)) + app.run(port=int(args.port), debug=not args.nodebug, host=args.address, + use_reloader=False) +else: + args, _ = parser.parse_known_args() + if args.public_host is None: + args.public_host = '%s:%d' % (socket.getfqdn(), int(args.port)) + load_projects(args.data) diff --git a/netdissect/server.yaml b/netdissect/server.yaml new file mode 100644 index 0000000000000000000000000000000000000000..9e67b9bbcb24397a21623009b4b6bf0e6d4c9193 --- /dev/null +++ b/netdissect/server.yaml @@ -0,0 +1,300 @@ +swagger: '2.0' +info: + title: Ganter API + version: "0.1" +consumes: + - application/json +produces: + - application/json + +basePath: /api + +paths: + /all_projects: + get: + tags: + - all + summary: information about all projects and sources available + operationId: netdissect.server.get_all_projects + responses: + 200: + description: return list of projects + schema: + type: array + items: + type: object + + /layers: + get: + operationId: netdissect.server.get_layers + tags: + - all + summary: returns information about all layers + parameters: + - $ref: '#/parameters/project' + responses: + 200: + description: Return requested data + schema: + type: object + + /units: + get: + operationId: netdissect.server.get_units + tags: + - all + summary: returns unit information for one layer + parameters: + + - $ref: '#/parameters/project' + - $ref: '#/parameters/layer' + + responses: + 200: + description: Return requested data + schema: + type: object + + /rankings: + get: + operationId: netdissect.server.get_rankings + tags: + - all + summary: returns ranking information for one layer + parameters: + + - $ref: '#/parameters/project' + - $ref: '#/parameters/layer' + + responses: + 200: + description: Return requested data + schema: + type: object + + /levels: + get: + operationId: netdissect.server.get_levels + tags: + - all + summary: returns feature levels for one layer + parameters: + + - $ref: '#/parameters/project' + - $ref: '#/parameters/layer' + - $ref: '#/parameters/quantiles' + + responses: + 200: + description: Return requested data + schema: + type: object + + /features: + post: + summary: calculates max feature values within a set of image locations + operationId: netdissect.server.post_features + tags: + - all + parameters: + - in: body + name: feat_req + description: RequestObject + schema: + $ref: "#/definitions/FeatureRequest" + responses: + 200: + description: returns feature vector for each layer + + /featuremaps: + post: + summary: calculates max feature values within a set of image locations + operationId: netdissect.server.post_featuremaps + tags: + - all + parameters: + - in: body + name: feat_req + description: RequestObject + schema: + $ref: "#/definitions/FeatureMapRequest" + responses: + 200: + description: returns feature vector for each layer + + /channels: + get: + operationId: netdissect.server.get_channels + tags: + - all + summary: returns channel information + parameters: + + - $ref: '#/parameters/project' + - $ref: '#/parameters/layer' + + responses: + 200: + description: Return requested data + schema: + type: object + + /generate: + post: + summary: generates images for given zs constrained by ablation + operationId: netdissect.server.post_generate + tags: + - all + parameters: + - in: body + name: gen_req + description: RequestObject + schema: + $ref: "#/definitions/GenerateRequest" + responses: + 200: + description: aaa + + +parameters: + project: + name: project + description: project ID + in: query + required: true + type: string + + layer: + name: layer + description: layer ID + in: query + type: string + default: "1" + + quantiles: + name: quantiles + in: query + type: array + items: + type: number + format: float + +definitions: + + GenerateRequest: + type: object + required: + - project + properties: + project: + type: string + zs: + type: array + items: + type: array + items: + type: number + format: float + ids: + type: array + items: + type: integer + return_urls: + type: integer + interventions: + type: array + items: + - $ref: '#/definitions/Intervention' + + FeatureRequest: + type: object + required: + - project + properties: + project: + type: string + example: 'churchoutdoor' + layers: + type: array + items: + type: string + example: [ 'layer5' ] + ids: + type: array + items: + type: integer + masks: + type: array + items: + - $ref: '#/definitions/Mask' + interventions: + type: array + items: + - $ref: '#/definitions/Intervention' + + FeatureMapRequest: + type: object + required: + - project + properties: + project: + type: string + example: 'churchoutdoor' + layers: + type: array + items: + type: string + example: [ 'layer5' ] + ids: + type: array + items: + type: integer + interventions: + type: array + items: + - $ref: '#/definitions/Intervention' + + Intervention: + type: object + properties: + maskalpha: + $ref: '#/definitions/Mask' + maskvalue: + $ref: '#/definitions/Mask' + ablations: + type: array + items: + - $ref: '#/definitions/Ablation' + + Ablation: + type: object + properties: + unit: + type: integer + alpha: + type: number + format: float + value: + type: number + format: float + layer: + type: string + + Mask: + type: object + description: 2d bitmap mask + properties: + shape: + type: array + items: + type: integer + example: [ 128, 128 ] + bitbounds: + type: array + items: + type: integer + example: [ 12, 42, 16, 46 ] + bitstring: + type: string + example: '0110111111110011' + diff --git a/netdissect/serverstate.py b/netdissect/serverstate.py new file mode 100644 index 0000000000000000000000000000000000000000..e7ddc790c3dfc881f8aa4322d10d90e4e4fc09f0 --- /dev/null +++ b/netdissect/serverstate.py @@ -0,0 +1,526 @@ +import os, torch, numpy, base64, json, re, threading, random +from torch.utils.data import TensorDataset, DataLoader +from collections import defaultdict +from netdissect.easydict import EasyDict +from netdissect.modelconfig import create_instrumented_model +from netdissect.runningstats import RunningQuantile +from netdissect.dissection import safe_dir_name +from netdissect.zdataset import z_sample_for_model +from PIL import Image +from io import BytesIO + +class DissectionProject: + ''' + DissectionProject understand how to drive a GanTester within a + dissection project directory structure: it caches data in files, + creates image files, and translates data between plain python data + types and the pytorch-specific tensors required by GanTester. + ''' + def __init__(self, config, project_dir, path_url, public_host): + print('config done', project_dir) + self.use_cuda = torch.cuda.is_available() + self.dissect = config + self.project_dir = project_dir + self.path_url = path_url + self.public_host = public_host + self.cachedir = os.path.join(self.project_dir, 'cache') + self.tester = GanTester( + config.settings, dissectdir=project_dir, + device=torch.device('cuda') if self.use_cuda + else torch.device('cpu')) + self.stdz = [] + + def get_zs(self, size): + if size <= len(self.stdz): + return self.stdz[:size].tolist() + z_tensor = self.tester.standard_z_sample(size) + numpy_z = z_tensor.cpu().numpy() + self.stdz = numpy_z + return self.stdz.tolist() + + def get_z(self, id): + if id < len(self.stdz): + return self.stdz[id] + return self.get_zs((id + 1) * 2)[id] + + def get_zs_for_ids(self, ids): + max_id = max(ids) + if max_id >= len(self.stdz): + self.get_z(max_id) + return self.stdz[ids] + + def get_layers(self): + result = [] + layer_shapes = self.tester.layer_shapes() + for layer in self.tester.layers: + shape = layer_shapes[layer] + result.append(dict( + layer=layer, + channels=shape[1], + shape=[shape[2], shape[3]])) + return result + + def get_units(self, layer): + try: + dlayer = [dl for dl in self.dissect['layers'] + if dl['layer'] == layer][0] + except: + return None + + dunits = dlayer['units'] + result = [dict(unit=unit_num, + img='/%s/%s/s-image/%d-top.jpg' % + (self.path_url, layer, unit_num), + label=unit['iou_label']) + for unit_num, unit in enumerate(dunits)] + return result + + def get_rankings(self, layer): + try: + dlayer = [dl for dl in self.dissect['layers'] + if dl['layer'] == layer][0] + except: + return None + result = [dict(name=ranking['name'], + metric=ranking.get('metric', None), + scores=ranking['score']) + for ranking in dlayer['rankings']] + return result + + def get_levels(self, layer, quantiles): + levels = self.tester.levels( + layer, torch.from_numpy(numpy.array(quantiles))) + return levels.cpu().numpy().tolist() + + def generate_images(self, zs, ids, interventions, return_urls=False): + if ids is not None: + assert zs is None + zs = self.get_zs_for_ids(ids) + if not interventions: + # Do file caching when ids are given (and no ablations). + imgdir = os.path.join(self.cachedir, 'img', 'id') + os.makedirs(imgdir, exist_ok=True) + exist = set(os.listdir(imgdir)) + unfinished = [('%d.jpg' % id) not in exist for id in ids] + needed_z_tensor = torch.tensor(zs[unfinished]).float().to( + self.tester.device) + needed_ids = numpy.array(ids)[unfinished] + # Generate image files for just the needed images. + if len(needed_z_tensor): + imgs = self.tester.generate_images(needed_z_tensor + ).cpu().numpy() + for i, img in zip(needed_ids, imgs): + Image.fromarray(img.transpose(1, 2, 0)).save( + os.path.join(imgdir, '%d.jpg' % i), 'jpeg', + quality=99, optimize=True, progressive=True) + # Assemble a response. + imgurls = ['/%s/cache/img/id/%d.jpg' + % (self.path_url, i) for i in ids] + return [dict(id=i, d=d) for i, d in zip(ids, imgurls)] + # No file caching when ids are not given (or ablations are applied) + z_tensor = torch.tensor(zs).float().to(self.tester.device) + imgs = self.tester.generate_images(z_tensor, + intervention=decode_intervention_array(interventions, + self.tester.layer_shapes()), + ).cpu().numpy() + numpy_z = z_tensor.cpu().numpy() + if return_urls: + randdir = '%03d' % random.randrange(1000) + imgdir = os.path.join(self.cachedir, 'img', 'uniq', randdir) + os.makedirs(imgdir, exist_ok=True) + startind = random.randrange(100000) + imgurls = [] + for i, img in enumerate(imgs): + filename = '%d.jpg' % (i + startind) + Image.fromarray(img.transpose(1, 2, 0)).save( + os.path.join(imgdir, filename), 'jpeg', + quality=99, optimize=True, progressive=True) + image_url_path = ('/%s/cache/img/uniq/%s/%s' + % (self.path_url, randdir, filename)) + imgurls.append(image_url_path) + tweet_filename = 'tweet-%d.html' % (i + startind) + tweet_url_path = ('/%s/cache/img/uniq/%s/%s' + % (self.path_url, randdir, tweet_filename)) + with open(os.path.join(imgdir, tweet_filename), 'w') as f: + f.write(twitter_card(image_url_path, tweet_url_path, + self.public_host)) + return [dict(d=d) for d in imgurls] + imgurls = [img2base64(img.transpose(1, 2, 0)) for img in imgs] + return [dict(d=d) for d in imgurls] + + def get_features(self, ids, masks, layers, interventions): + zs = self.get_zs_for_ids(ids) + z_tensor = torch.tensor(zs).float().to(self.tester.device) + t_masks = torch.stack( + [torch.from_numpy(mask_to_numpy(mask)) for mask in masks] + )[:,None,:,:].to(self.tester.device) + t_features = self.tester.feature_stats(z_tensor, t_masks, + decode_intervention_array(interventions, + self.tester.layer_shapes()), layers) + # Convert torch arrays to plain python lists before returning. + return { layer: { key: value.cpu().numpy().tolist() + for key, value in feature.items() } + for layer, feature in t_features.items() } + + def get_featuremaps(self, ids, layers, interventions): + zs = self.get_zs_for_ids(ids) + z_tensor = torch.tensor(zs).float().to(self.tester.device) + # Quantilized features are returned. + q_features = self.tester.feature_maps(z_tensor, + decode_intervention_array(interventions, + self.tester.layer_shapes()), layers) + # Scale them 0-255 and return them. + # TODO: turn them into pngs for returning. + return { layer: [ + value.clamp(0, 1).mul(255).byte().cpu().numpy().tolist() + for value in valuelist ] + for layer, valuelist in q_features.items() + if (not layers) or (layer in layers) } + + def get_recipes(self): + recipedir = os.path.join(self.project_dir, 'recipe') + if not os.path.isdir(recipedir): + return [] + result = [] + for filename in os.listdir(recipedir): + with open(os.path.join(recipedir, filename)) as f: + result.append(json.load(f)) + return result + + + + +class GanTester: + ''' + GanTester holds on to a specific model to test. + + (1) loads and instantiates the GAN; + (2) instruments it at every layer so that units can be ablated + (3) precomputes z dimensionality, and output image dimensions. + ''' + def __init__(self, args, dissectdir=None, device=None): + self.cachedir = os.path.join(dissectdir, 'cache') + self.device = device if device is not None else torch.device('cpu') + self.dissectdir = dissectdir + self.modellock = threading.Lock() + + # Load the generator from the pth file. + args_copy = EasyDict(args) + args_copy.edit = True + model = create_instrumented_model(args_copy) + model.eval() + self.model = model + + # Get the set of layers of interest. + # Default: all shallow children except last. + self.layers = sorted(model.retained_features().keys()) + + # Move it to CUDA if wanted. + model.to(device) + + self.quantiles = { + layer: load_quantile_if_present(os.path.join(self.dissectdir, + safe_dir_name(layer)), 'quantiles.npz', + device=torch.device('cpu')) + for layer in self.layers } + + def layer_shapes(self): + return self.model.feature_shape + + def standard_z_sample(self, size=100, seed=1, device=None): + ''' + Generate a standard set of random Z as a (size, z_dimension) tensor. + With the same random seed, it always returns the same z (e.g., + the first one is always the same regardless of the size.) + ''' + result = z_sample_for_model(self.model, size) + if device is not None: + result = result.to(device) + return result + + def reset_intervention(self): + self.model.remove_edits() + + def apply_intervention(self, intervention): + ''' + Applies an ablation recipe of the form [(layer, unit, alpha)...]. + ''' + self.reset_intervention() + if not intervention: + return + for layer, (a, v) in intervention.items(): + self.model.edit_layer(layer, ablation=a, replacement=v) + + def generate_images(self, z_batch, intervention=None): + ''' + Makes some images. + ''' + with torch.no_grad(), self.modellock: + batch_size = 10 + self.apply_intervention(intervention) + test_loader = DataLoader(TensorDataset(z_batch[:,:,None,None]), + batch_size=batch_size, + pin_memory=('cuda' == self.device.type + and z_batch.device.type == 'cpu')) + result_img = torch.zeros( + *((len(z_batch), 3) + self.model.output_shape[2:]), + dtype=torch.uint8, device=self.device) + for batch_num, [batch_z,] in enumerate(test_loader): + batch_z = batch_z.to(self.device) + out = self.model(batch_z) + result_img[batch_num*batch_size: + batch_num*batch_size+len(batch_z)] = ( + (((out + 1) / 2) * 255).clamp(0, 255).byte()) + return result_img + + def get_layers(self): + return self.layers + + def feature_stats(self, z_batch, + masks=None, intervention=None, layers=None): + feature_stat = defaultdict(dict) + with torch.no_grad(), self.modellock: + batch_size = 10 + self.apply_intervention(intervention) + if masks is None: + masks = torch.ones(z_batch.size(0), 1, 1, 1, + device=z_batch.device, dtype=z_batch.dtype) + else: + assert masks.shape[0] == z_batch.shape[0] + assert masks.shape[1] == 1 + test_loader = DataLoader( + TensorDataset(z_batch[:,:,None,None], masks), + batch_size=batch_size, + pin_memory=('cuda' == self.device.type + and z_batch.device.type == 'cpu')) + processed = 0 + for batch_num, [batch_z, batch_m] in enumerate(test_loader): + batch_z, batch_m = [ + d.to(self.device) for d in [batch_z, batch_m]] + # Run model but disregard output + self.model(batch_z) + processing = batch_z.shape[0] + for layer, feature in self.model.retained_features().items(): + if layers is not None: + if layer not in layers: + continue + # Compute max features touching mask + resized_max = torch.nn.functional.adaptive_max_pool2d( + batch_m, + (feature.shape[2], feature.shape[3])) + max_feature = (feature * resized_max).view( + feature.shape[0], feature.shape[1], -1 + ).max(2)[0].max(0)[0] + if 'max' not in feature_stat[layer]: + feature_stat[layer]['max'] = max_feature + else: + torch.max(feature_stat[layer]['max'], max_feature, + out=feature_stat[layer]['max']) + # Compute mean features weighted by overlap with mask + resized_mean = torch.nn.functional.adaptive_avg_pool2d( + batch_m, + (feature.shape[2], feature.shape[3])) + mean_feature = (feature * resized_mean).view( + feature.shape[0], feature.shape[1], -1 + ).sum(2).sum(0) / (resized_mean.sum() + 1e-15) + if 'mean' not in feature_stat[layer]: + feature_stat[layer]['mean'] = mean_feature + else: + feature_stat[layer]['mean'] = ( + processed * feature_mean[layer]['mean'] + + processing * mean_feature) / ( + processed + processing) + processed += processing + # After summaries are done, also compute quantile stats + for layer, stats in feature_stat.items(): + if self.quantiles.get(layer, None) is not None: + for statname in ['max', 'mean']: + stats['%s_quantile' % statname] = ( + self.quantiles[layer].normalize(stats[statname])) + return feature_stat + + def levels(self, layer, quantiles): + return self.quantiles[layer].quantiles(quantiles) + + def feature_maps(self, z_batch, intervention=None, layers=None, + quantiles=True): + feature_map = defaultdict(list) + with torch.no_grad(), self.modellock: + batch_size = 10 + self.apply_intervention(intervention) + test_loader = DataLoader( + TensorDataset(z_batch[:,:,None,None]), + batch_size=batch_size, + pin_memory=('cuda' == self.device.type + and z_batch.device.type == 'cpu')) + processed = 0 + for batch_num, [batch_z] in enumerate(test_loader): + batch_z = batch_z.to(self.device) + # Run model but disregard output + self.model(batch_z) + processing = batch_z.shape[0] + for layer, feature in self.model.retained_features().items(): + for single_featuremap in feature: + if quantiles: + feature_map[layer].append(self.quantiles[layer] + .normalize(single_featuremap)) + else: + feature_map[layer].append(single_featuremap) + return feature_map + +def load_quantile_if_present(outdir, filename, device): + filepath = os.path.join(outdir, filename) + if os.path.isfile(filepath): + data = numpy.load(filepath) + result = RunningQuantile(state=data) + result.to_(device) + return result + return None + +if __name__ == '__main__': + test_main() + +def mask_to_numpy(mask_record): + # Detect a png image mask. + bitstring = mask_record['bitstring'] + bitnumpy = None + default_shape = (256, 256) + if 'image/png;base64,' in bitstring: + bitnumpy = base642img(bitstring) + default_shape = bitnumpy.shape[:2] + # Set up results + shape = mask_record.get('shape', None) + if not shape: # None or empty [] + shape = default_shape + result = numpy.zeros(shape=shape, dtype=numpy.float32) + bitbounds = mask_record.get('bitbounds', None) + if not bitbounds: # None or empty [] + bitbounds = ([0] * len(result.shape)) + list(result.shape) + start = bitbounds[:len(result.shape)] + end = bitbounds[len(result.shape):] + if bitnumpy is not None: + if bitnumpy.shape[2] == 4: + # Mask is any nontransparent bits in the alpha channel if present + result[start[0]:end[0], start[1]:end[1]] = (bitnumpy[:,:,3] > 0) + else: + # Or any nonwhite pixels in the red channel if no alpha. + result[start[0]:end[0], start[1]:end[1]] = (bitnumpy[:,:,0] < 255) + return result + else: + # Or bitstring can be just ones and zeros. + indexes = start.copy() + bitindex = 0 + while True: + result[tuple(indexes)] = (bitstring[bitindex] != '0') + for ii in range(len(indexes) - 1, -1, -1): + if indexes[ii] < end[ii] - 1: + break + indexes[ii] = start[ii] + else: + assert (bitindex + 1) == len(bitstring) + return result + indexes[ii] += 1 + bitindex += 1 + +def decode_intervention_array(interventions, layer_shapes): + result = {} + for channels in [decode_intervention(intervention, layer_shapes) + for intervention in (interventions or [])]: + for layer, channel in channels.items(): + if layer not in result: + result[layer] = channel + continue + accum = result[layer] + newalpha = 1 - (1 - channel[:1]) * (1 - accum[:1]) + newvalue = (accum[1:] * accum[:1] * (1 - channel[:1]) + + channel[1:] * channel[:1]) / (newalpha + 1e-40) + accum[:1] = newalpha + accum[1:] = newvalue + return result + +def decode_intervention(intervention, layer_shapes): + # Every plane of an intervention is a solid choice of activation + # over a set of channels, with a mask applied to alpha-blended channels + # (when the mask resolution is different from the feature map, it can + # be either a max-pooled or average-pooled to the proper resolution). + # This can be reduced to a single alpha-blended featuremap. + if intervention is None: + return None + mask = intervention.get('mask', None) + if mask: + mask = torch.from_numpy(mask_to_numpy(mask)) + maskpooling = intervention.get('maskpooling', 'max') + channels = {} # layer -> ([alpha, val], c) + for arec in intervention.get('ablations', []): + unit = arec['unit'] + layer = arec['layer'] + alpha = arec.get('alpha', 1.0) + if alpha is None: + alpha = 1.0 + value = arec.get('value', 0.0) + if value is None: + value = 0.0 + if alpha != 0.0 or value != 0.0: + if layer not in channels: + channels[layer] = torch.zeros(2, *layer_shapes[layer][1:]) + channels[layer][0, unit] = alpha + channels[layer][1, unit] = value + if mask is not None: + for layer in channels: + layer_shape = layer_shapes[layer][2:] + if maskpooling == 'mean': + layer_mask = torch.nn.functional.adaptive_avg_pool2d( + mask[None,None,...], layer_shape)[0] + else: + layer_mask = torch.nn.functional.adaptive_max_pool2d( + mask[None,None,...], layer_shape)[0] + channels[layer][0] *= layer_mask + return channels + +def img2base64(imgarray, for_html=True, image_format='jpeg'): + ''' + Converts a numpy array to a jpeg base64 url + ''' + input_image_buff = BytesIO() + Image.fromarray(imgarray).save(input_image_buff, image_format, + quality=99, optimize=True, progressive=True) + res = base64.b64encode(input_image_buff.getvalue()).decode('ascii') + if for_html: + return 'data:image/' + image_format + ';base64,' + res + else: + return res + +def base642img(stringdata): + stringdata = re.sub('^(?:data:)?image/\w+;base64,', '', stringdata) + im = Image.open(BytesIO(base64.b64decode(stringdata))) + return numpy.array(im) + +def twitter_card(image_path, tweet_path, public_host): + return '''\ + + + + + + + + + + + + +
+

Painting with GANs from MIT-IBM Watson AI Lab

+

This demo lets you modify a selection of meatningful GAN units for a generated image by simply painting.

+ +

Redirecting to +GANPaint +

+
+ +'''.format( + image_path=image_path, + tweet_path=tweet_path, + public_host=public_host) diff --git a/netdissect/statedict.py b/netdissect/statedict.py new file mode 100644 index 0000000000000000000000000000000000000000..858a903b57724d9e3a17b8150beea30bdc206b97 --- /dev/null +++ b/netdissect/statedict.py @@ -0,0 +1,100 @@ +''' +Utilities for dealing with simple state dicts as npz files instead of pth files. +''' + +import torch +from collections.abc import MutableMapping, Mapping + +def load_from_numpy_dict(model, numpy_dict, prefix='', examples=None): + ''' + Loads a model from numpy_dict using load_state_dict. + Converts numpy types to torch types using the current state_dict + of the model to determine types and devices for the tensors. + Supports loading a subdict by prepending the given prefix to all keys. + ''' + if prefix: + if not prefix.endswith('.'): + prefix = prefix + '.' + numpy_dict = PrefixSubDict(numpy_dict, prefix) + if examples is None: + exampels = model.state_dict() + torch_state_dict = TorchTypeMatchingDict(numpy_dict, examples) + model.load_state_dict(torch_state_dict) + +def save_to_numpy_dict(model, numpy_dict, prefix=''): + ''' + Saves a model by copying tensors to numpy_dict. + Converts torch types to numpy types using `t.detach().cpu().numpy()`. + Supports saving a subdict by prepending the given prefix to all keys. + ''' + if prefix: + if not prefix.endswith('.'): + prefix = prefix + '.' + for k, v in model.numpy_dict().items(): + if isinstance(v, torch.Tensor): + v = v.detach().cpu().numpy() + numpy_dict[prefix + k] = v + +class TorchTypeMatchingDict(Mapping): + ''' + Provides a view of a dict of numpy values as torch tensors, where the + types are converted to match the types and devices in the given + dict of examples. + ''' + def __init__(self, data, examples): + self.data = data + self.examples = examples + self.cached_data = {} + def __getitem__(self, key): + if key in self.cached_data: + return self.cached_data[key] + val = self.data[key] + if key not in self.examples: + return val + example = self.examples.get(key, None) + example_type = type(example) + if example is not None and type(val) != example_type: + if isinstance(example, torch.Tensor): + val = torch.from_numpy(val) + else: + val = example_type(val) + if isinstance(example, torch.Tensor): + val = val.to(dtype=example.dtype, device=example.device) + self.cached_data[key] = val + return val + def __iter__(self): + return self.data.keys() + def __len__(self): + return len(self.data) + +class PrefixSubDict(MutableMapping): + ''' + Provides a view of the subset of a dict where string keys begin with + the given prefix. The prefix is stripped from all keys of the view. + ''' + def __init__(self, data, prefix=''): + self.data = data + self.prefix = prefix + self._cached_keys = None + def __getitem__(self, key): + return self.data[self.prefix + key] + def __setitem__(self, key, value): + pkey = self.prefix + key + if self._cached_keys is not None and pkey not in self.data: + self._cached_keys = None + self.data[pkey] = value + def __delitem__(self, key): + pkey = self.prefix + key + if self._cached_keys is not None and pkey in self.data: + self._cached_keys = None + del self.data[pkey] + def __cached_keys(self): + if self._cached_keys is None: + plen = len(self.prefix) + self._cached_keys = list(k[plen:] for k in self.data + if k.startswith(self.prefix)) + return self._cached_keys + def __iter__(self): + return iter(self.__cached_keys()) + def __len__(self): + return len(self.__cached_keys()) diff --git a/netdissect/tool/allunitsample.py b/netdissect/tool/allunitsample.py new file mode 100644 index 0000000000000000000000000000000000000000..9f86e196ce63ebfcad1fcee8bd2b7358463ff3d1 --- /dev/null +++ b/netdissect/tool/allunitsample.py @@ -0,0 +1,199 @@ +''' +A simple tool to generate sample of output of a GAN, +subject to filtering, sorting, or intervention. +''' + +import torch, numpy, os, argparse, sys, shutil, errno, numbers +from PIL import Image +from torch.utils.data import TensorDataset +from netdissect.zdataset import standard_z_sample +from netdissect.progress import default_progress, verbose_progress +from netdissect.autoeval import autoimport_eval +from netdissect.workerpool import WorkerBase, WorkerPool +from netdissect.nethook import retain_layers +from netdissect.runningstats import RunningTopK + +def main(): + parser = argparse.ArgumentParser(description='GAN sample making utility') + parser.add_argument('--model', type=str, default=None, + help='constructor for the model to test') + parser.add_argument('--pthfile', type=str, default=None, + help='filename of .pth file for the model') + parser.add_argument('--outdir', type=str, default='images', + help='directory for image output') + parser.add_argument('--size', type=int, default=100, + help='number of images to output') + parser.add_argument('--test_size', type=int, default=None, + help='number of images to test') + parser.add_argument('--layer', type=str, default=None, + help='layer to inspect') + parser.add_argument('--seed', type=int, default=1, + help='seed') + parser.add_argument('--quiet', action='store_true', default=False, + help='silences console output') + if len(sys.argv) == 1: + parser.print_usage(sys.stderr) + sys.exit(1) + args = parser.parse_args() + verbose_progress(not args.quiet) + + # Instantiate the model + model = autoimport_eval(args.model) + if args.pthfile is not None: + data = torch.load(args.pthfile) + if 'state_dict' in data: + meta = {} + for key in data: + if isinstance(data[key], numbers.Number): + meta[key] = data[key] + data = data['state_dict'] + model.load_state_dict(data) + # Unwrap any DataParallel-wrapped model + if isinstance(model, torch.nn.DataParallel): + model = next(model.children()) + # Examine first conv in model to determine input feature size. + first_layer = [c for c in model.modules() + if isinstance(c, (torch.nn.Conv2d, torch.nn.ConvTranspose2d, + torch.nn.Linear))][0] + # 4d input if convolutional, 2d input if first layer is linear. + if isinstance(first_layer, (torch.nn.Conv2d, torch.nn.ConvTranspose2d)): + z_channels = first_layer.in_channels + spatialdims = (1, 1) + else: + z_channels = first_layer.in_features + spatialdims = () + # Instrument the model + retain_layers(model, [args.layer]) + model.cuda() + + if args.test_size is None: + args.test_size = args.size * 20 + z_universe = standard_z_sample(args.test_size, z_channels, + seed=args.seed) + z_universe = z_universe.view(tuple(z_universe.shape) + spatialdims) + indexes = get_all_highest_znums( + model, z_universe, args.size, seed=args.seed) + save_chosen_unit_images(args.outdir, model, z_universe, indexes, + lightbox=True) + + +def get_all_highest_znums(model, z_universe, size, + batch_size=10, seed=1): + # The model should have been instrumented already + retained_items = list(model.retained.items()) + assert len(retained_items) == 1 + layer = retained_items[0][0] + # By default, a 10% sample + progress = default_progress() + num_units = None + with torch.no_grad(): + # Pass 1: collect max activation stats + z_loader = torch.utils.data.DataLoader(TensorDataset(z_universe), + batch_size=batch_size, num_workers=2, + pin_memory=True) + rtk = RunningTopK(k=size) + for [z] in progress(z_loader, desc='Finding max activations'): + z = z.cuda() + model(z) + feature = model.retained[layer] + num_units = feature.shape[1] + max_feature = feature.view( + feature.shape[0], num_units, -1).max(2)[0] + rtk.add(max_feature) + td, ti = rtk.result() + highest = ti.sort(1)[0] + return highest + +def save_chosen_unit_images(dirname, model, z_universe, indices, + shared_dir="shared_images", + unitdir_template="unit_{}", + name_template="image_{}.jpg", + lightbox=False, batch_size=50, seed=1): + all_indices = torch.unique(indices.view(-1), sorted=True) + z_sample = z_universe[all_indices] + progress = default_progress() + sdir = os.path.join(dirname, shared_dir) + created_hashdirs = set() + for index in range(len(z_universe)): + hd = hashdir(index) + if hd not in created_hashdirs: + created_hashdirs.add(hd) + os.makedirs(os.path.join(sdir, hd), exist_ok=True) + with torch.no_grad(): + # Pass 2: now generate images + z_loader = torch.utils.data.DataLoader(TensorDataset(z_sample), + batch_size=batch_size, num_workers=2, + pin_memory=True) + saver = WorkerPool(SaveImageWorker) + for batch_num, [z] in enumerate(progress(z_loader, + desc='Saving images')): + z = z.cuda() + start_index = batch_num * batch_size + im = ((model(z) + 1) / 2 * 255).clamp(0, 255).byte().permute( + 0, 2, 3, 1).cpu() + for i in range(len(im)): + index = all_indices[i + start_index].item() + filename = os.path.join(sdir, hashdir(index), + name_template.format(index)) + saver.add(im[i].numpy(), filename) + saver.join() + linker = WorkerPool(MakeLinkWorker) + for u in progress(range(len(indices)), desc='Making links'): + udir = os.path.join(dirname, unitdir_template.format(u)) + os.makedirs(udir, exist_ok=True) + for r in range(indices.shape[1]): + index = indices[u,r].item() + fn = name_template.format(index) + # sourcename = os.path.join('..', shared_dir, fn) + sourcename = os.path.join(sdir, hashdir(index), fn) + targname = os.path.join(udir, fn) + linker.add(sourcename, targname) + if lightbox: + copy_lightbox_to(udir) + linker.join() + +def copy_lightbox_to(dirname): + srcdir = os.path.realpath( + os.path.join(os.getcwd(), os.path.dirname(__file__))) + shutil.copy(os.path.join(srcdir, 'lightbox.html'), + os.path.join(dirname, '+lightbox.html')) + +def hashdir(index): + # To keep the number of files the shared directory lower, split it + # into 100 subdirectories named as follows. + return '%02d' % (index % 100) + +class SaveImageWorker(WorkerBase): + # Saving images can be sped up by sending jpeg encoding and + # file-writing work to a pool. + def work(self, data, filename): + Image.fromarray(data).save(filename, optimize=True, quality=100) + +class MakeLinkWorker(WorkerBase): + # Creating symbolic links is a bit slow and can be done faster + # in parallel rather than waiting for each to be created. + def work(self, sourcename, targname): + try: + os.link(sourcename, targname) + except OSError as e: + if e.errno == errno.EEXIST: + os.remove(targname) + os.link(sourcename, targname) + else: + raise + +class MakeSyminkWorker(WorkerBase): + # Creating symbolic links is a bit slow and can be done faster + # in parallel rather than waiting for each to be created. + def work(self, sourcename, targname): + try: + os.symlink(sourcename, targname) + except OSError as e: + if e.errno == errno.EEXIST: + os.remove(targname) + os.symlink(sourcename, targname) + else: + raise + +if __name__ == '__main__': + main() diff --git a/netdissect/tool/ganseg.py b/netdissect/tool/ganseg.py new file mode 100644 index 0000000000000000000000000000000000000000..e6225736d336cf75aedb8a7d7aec1229b497f6a9 --- /dev/null +++ b/netdissect/tool/ganseg.py @@ -0,0 +1,89 @@ +''' +A simple tool to generate sample of output of a GAN, +and apply semantic segmentation on the output. +''' + +import torch, numpy, os, argparse, sys, shutil +from PIL import Image +from torch.utils.data import TensorDataset +from netdissect.zdataset import standard_z_sample, z_dataset_for_model +from netdissect.progress import default_progress, verbose_progress +from netdissect.autoeval import autoimport_eval +from netdissect.workerpool import WorkerBase, WorkerPool +from netdissect.nethook import edit_layers, retain_layers +from netdissect.segviz import segment_visualization +from netdissect.segmenter import UnifiedParsingSegmenter +from scipy.io import savemat + +def main(): + parser = argparse.ArgumentParser(description='GAN output segmentation util') + parser.add_argument('--model', type=str, default= + 'netdissect.proggan.from_pth_file("' + + 'models/karras/churchoutdoor_lsun.pth")', + help='constructor for the model to test') + parser.add_argument('--outdir', type=str, default='images', + help='directory for image output') + parser.add_argument('--size', type=int, default=100, + help='number of images to output') + parser.add_argument('--seed', type=int, default=1, + help='seed') + parser.add_argument('--quiet', action='store_true', default=False, + help='silences console output') + #if len(sys.argv) == 1: + # parser.print_usage(sys.stderr) + # sys.exit(1) + args = parser.parse_args() + verbose_progress(not args.quiet) + + # Instantiate the model + model = autoimport_eval(args.model) + + # Make the standard z + z_dataset = z_dataset_for_model(model, size=args.size) + + # Make the segmenter + segmenter = UnifiedParsingSegmenter() + + # Write out text labels + labels, cats = segmenter.get_label_and_category_names() + with open(os.path.join(args.outdir, 'labels.txt'), 'w') as f: + for i, (label, cat) in enumerate(labels): + f.write('%s %s\n' % (label, cat)) + + # Move models to cuda + model.cuda() + + batch_size = 10 + progress = default_progress() + dirname = args.outdir + + with torch.no_grad(): + # Pass 2: now generate images + z_loader = torch.utils.data.DataLoader(z_dataset, + batch_size=batch_size, num_workers=2, + pin_memory=True) + for batch_num, [z] in enumerate(progress(z_loader, + desc='Saving images')): + z = z.cuda() + start_index = batch_num * batch_size + tensor_im = model(z) + byte_im = ((tensor_im + 1) / 2 * 255).clamp(0, 255).byte().permute( + 0, 2, 3, 1).cpu() + seg = segmenter.segment_batch(tensor_im) + for i in range(len(tensor_im)): + index = i + start_index + filename = os.path.join(dirname, '%d_img.jpg' % index) + Image.fromarray(byte_im[i].numpy()).save( + filename, optimize=True, quality=100) + filename = os.path.join(dirname, '%d_seg.mat' % index) + savemat(filename, dict(seg=seg[i].cpu().numpy())) + filename = os.path.join(dirname, '%d_seg.png' % index) + Image.fromarray(segment_visualization(seg[i].cpu().numpy(), + tensor_im.shape[2:])).save(filename) + srcdir = os.path.realpath( + os.path.join(os.getcwd(), os.path.dirname(__file__))) + shutil.copy(os.path.join(srcdir, 'lightbox.html'), + os.path.join(dirname, '+lightbox.html')) + +if __name__ == '__main__': + main() diff --git a/netdissect/tool/lightbox.html b/netdissect/tool/lightbox.html new file mode 100644 index 0000000000000000000000000000000000000000..fb0ebdf64766a43c9353428853be77deb5c52665 --- /dev/null +++ b/netdissect/tool/lightbox.html @@ -0,0 +1,59 @@ + + + + + + + + + + + + +
+

Images in {{ directory }}

+
+
{{ r }}
+ +
+
+ + + diff --git a/netdissect/tool/makesample.py b/netdissect/tool/makesample.py new file mode 100644 index 0000000000000000000000000000000000000000..36276267677360d8238a8dbf71e9753dcc327681 --- /dev/null +++ b/netdissect/tool/makesample.py @@ -0,0 +1,169 @@ +''' +A simple tool to generate sample of output of a GAN, +subject to filtering, sorting, or intervention. +''' + +import torch, numpy, os, argparse, numbers, sys, shutil +from PIL import Image +from torch.utils.data import TensorDataset +from netdissect.zdataset import standard_z_sample +from netdissect.progress import default_progress, verbose_progress +from netdissect.autoeval import autoimport_eval +from netdissect.workerpool import WorkerBase, WorkerPool +from netdissect.nethook import edit_layers, retain_layers + +def main(): + parser = argparse.ArgumentParser(description='GAN sample making utility') + parser.add_argument('--model', type=str, default=None, + help='constructor for the model to test') + parser.add_argument('--pthfile', type=str, default=None, + help='filename of .pth file for the model') + parser.add_argument('--outdir', type=str, default='images', + help='directory for image output') + parser.add_argument('--size', type=int, default=100, + help='number of images to output') + parser.add_argument('--test_size', type=int, default=None, + help='number of images to test') + parser.add_argument('--layer', type=str, default=None, + help='layer to inspect') + parser.add_argument('--seed', type=int, default=1, + help='seed') + parser.add_argument('--maximize_units', type=int, nargs='+', default=None, + help='units to maximize') + parser.add_argument('--ablate_units', type=int, nargs='+', default=None, + help='units to ablate') + parser.add_argument('--quiet', action='store_true', default=False, + help='silences console output') + if len(sys.argv) == 1: + parser.print_usage(sys.stderr) + sys.exit(1) + args = parser.parse_args() + verbose_progress(not args.quiet) + + # Instantiate the model + model = autoimport_eval(args.model) + if args.pthfile is not None: + data = torch.load(args.pthfile) + if 'state_dict' in data: + meta = {} + for key in data: + if isinstance(data[key], numbers.Number): + meta[key] = data[key] + data = data['state_dict'] + model.load_state_dict(data) + # Unwrap any DataParallel-wrapped model + if isinstance(model, torch.nn.DataParallel): + model = next(model.children()) + # Examine first conv in model to determine input feature size. + first_layer = [c for c in model.modules() + if isinstance(c, (torch.nn.Conv2d, torch.nn.ConvTranspose2d, + torch.nn.Linear))][0] + # 4d input if convolutional, 2d input if first layer is linear. + if isinstance(first_layer, (torch.nn.Conv2d, torch.nn.ConvTranspose2d)): + z_channels = first_layer.in_channels + spatialdims = (1, 1) + else: + z_channels = first_layer.in_features + spatialdims = () + # Instrument the model if needed + if args.maximize_units is not None: + retain_layers(model, [args.layer]) + model.cuda() + + # Get the sample of z vectors + if args.maximize_units is None: + indexes = torch.arange(args.size) + z_sample = standard_z_sample(args.size, z_channels, seed=args.seed) + z_sample = z_sample.view(tuple(z_sample.shape) + spatialdims) + else: + # By default, if maximizing units, get a 'top 5%' sample. + if args.test_size is None: + args.test_size = args.size * 20 + z_universe = standard_z_sample(args.test_size, z_channels, + seed=args.seed) + z_universe = z_universe.view(tuple(z_universe.shape) + spatialdims) + indexes = get_highest_znums(model, z_universe, args.maximize_units, + args.size, seed=args.seed) + z_sample = z_universe[indexes] + + if args.ablate_units: + edit_layers(model, [args.layer]) + dims = max(2, max(args.ablate_units) + 1) # >=2 to avoid broadcast + model.ablation[args.layer] = torch.zeros(dims) + model.ablation[args.layer][args.ablate_units] = 1 + + save_znum_images(args.outdir, model, z_sample, indexes, + args.layer, args.ablate_units) + copy_lightbox_to(args.outdir) + + +def get_highest_znums(model, z_universe, max_units, size, + batch_size=100, seed=1): + # The model should have been instrumented already + retained_items = list(model.retained.items()) + assert len(retained_items) == 1 + layer = retained_items[0][0] + # By default, a 10% sample + progress = default_progress() + num_units = None + with torch.no_grad(): + # Pass 1: collect max activation stats + z_loader = torch.utils.data.DataLoader(TensorDataset(z_universe), + batch_size=batch_size, num_workers=2, + pin_memory=True) + scores = [] + for [z] in progress(z_loader, desc='Finding max activations'): + z = z.cuda() + model(z) + feature = model.retained[layer] + num_units = feature.shape[1] + max_feature = feature[:, max_units, ...].view( + feature.shape[0], len(max_units), -1).max(2)[0] + total_feature = max_feature.sum(1) + scores.append(total_feature.cpu()) + scores = torch.cat(scores, 0) + highest = (-scores).sort(0)[1][:size].sort(0)[0] + return highest + + +def save_znum_images(dirname, model, z_sample, indexes, layer, ablated_units, + name_template="image_{}.png", lightbox=False, batch_size=100, seed=1): + progress = default_progress() + os.makedirs(dirname, exist_ok=True) + with torch.no_grad(): + # Pass 2: now generate images + z_loader = torch.utils.data.DataLoader(TensorDataset(z_sample), + batch_size=batch_size, num_workers=2, + pin_memory=True) + saver = WorkerPool(SaveImageWorker) + if ablated_units is not None: + dims = max(2, max(ablated_units) + 1) # >=2 to avoid broadcast + mask = torch.zeros(dims) + mask[ablated_units] = 1 + model.ablation[layer] = mask[None,:,None,None].cuda() + for batch_num, [z] in enumerate(progress(z_loader, + desc='Saving images')): + z = z.cuda() + start_index = batch_num * batch_size + im = ((model(z) + 1) / 2 * 255).clamp(0, 255).byte().permute( + 0, 2, 3, 1).cpu() + for i in range(len(im)): + index = i + start_index + if indexes is not None: + index = indexes[index].item() + filename = os.path.join(dirname, name_template.format(index)) + saver.add(im[i].numpy(), filename) + saver.join() + +def copy_lightbox_to(dirname): + srcdir = os.path.realpath( + os.path.join(os.getcwd(), os.path.dirname(__file__))) + shutil.copy(os.path.join(srcdir, 'lightbox.html'), + os.path.join(dirname, '+lightbox.html')) + +class SaveImageWorker(WorkerBase): + def work(self, data, filename): + Image.fromarray(data).save(filename, optimize=True, quality=100) + +if __name__ == '__main__': + main() diff --git a/netdissect/upsegmodel/__init__.py b/netdissect/upsegmodel/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..76b40a0a36bc2976f185dbdc344c5a7c09b65920 --- /dev/null +++ b/netdissect/upsegmodel/__init__.py @@ -0,0 +1 @@ +from .models import ModelBuilder, SegmentationModule diff --git a/netdissect/upsegmodel/__pycache__/__init__.cpython-310.pyc b/netdissect/upsegmodel/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..45f357ccaca63c1d46405b36819d6714299271c6 Binary files /dev/null and b/netdissect/upsegmodel/__pycache__/__init__.cpython-310.pyc differ diff --git a/netdissect/upsegmodel/__pycache__/models.cpython-310.pyc b/netdissect/upsegmodel/__pycache__/models.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9173d8af4d60664740ebc4b9daf42466a80508b3 Binary files /dev/null and b/netdissect/upsegmodel/__pycache__/models.cpython-310.pyc differ diff --git a/netdissect/upsegmodel/__pycache__/resnet.cpython-310.pyc b/netdissect/upsegmodel/__pycache__/resnet.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c52f31d248c76a8953d37718a2e31c1359785295 Binary files /dev/null and b/netdissect/upsegmodel/__pycache__/resnet.cpython-310.pyc differ diff --git a/netdissect/upsegmodel/__pycache__/resnext.cpython-310.pyc b/netdissect/upsegmodel/__pycache__/resnext.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d55fa54c82d3a1f3be8b4e4f390482d62f6ad124 Binary files /dev/null and b/netdissect/upsegmodel/__pycache__/resnext.cpython-310.pyc differ diff --git a/netdissect/upsegmodel/models.py b/netdissect/upsegmodel/models.py new file mode 100644 index 0000000000000000000000000000000000000000..de0a9add41016631957c52c4a441e4eccf96f903 --- /dev/null +++ b/netdissect/upsegmodel/models.py @@ -0,0 +1,441 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +import torchvision +from . import resnet, resnext +try: + from lib.nn import SynchronizedBatchNorm2d +except ImportError: + from torch.nn import BatchNorm2d as SynchronizedBatchNorm2d + + +class SegmentationModuleBase(nn.Module): + def __init__(self): + super(SegmentationModuleBase, self).__init__() + + @staticmethod + def pixel_acc(pred, label, ignore_index=-1): + _, preds = torch.max(pred, dim=1) + valid = (label != ignore_index).long() + acc_sum = torch.sum(valid * (preds == label).long()) + pixel_sum = torch.sum(valid) + acc = acc_sum.float() / (pixel_sum.float() + 1e-10) + return acc + + @staticmethod + def part_pixel_acc(pred_part, gt_seg_part, gt_seg_object, object_label, valid): + mask_object = (gt_seg_object == object_label) + _, pred = torch.max(pred_part, dim=1) + acc_sum = mask_object * (pred == gt_seg_part) + acc_sum = torch.sum(acc_sum.view(acc_sum.size(0), -1), dim=1) + acc_sum = torch.sum(acc_sum * valid) + pixel_sum = torch.sum(mask_object.view(mask_object.size(0), -1), dim=1) + pixel_sum = torch.sum(pixel_sum * valid) + return acc_sum, pixel_sum + + @staticmethod + def part_loss(pred_part, gt_seg_part, gt_seg_object, object_label, valid): + mask_object = (gt_seg_object == object_label) + loss = F.nll_loss(pred_part, gt_seg_part * mask_object.long(), reduction='none') + loss = loss * mask_object.float() + loss = torch.sum(loss.view(loss.size(0), -1), dim=1) + nr_pixel = torch.sum(mask_object.view(mask_object.shape[0], -1), dim=1) + sum_pixel = (nr_pixel * valid).sum() + loss = (loss * valid.float()).sum() / torch.clamp(sum_pixel, 1).float() + return loss + + +class SegmentationModule(SegmentationModuleBase): + def __init__(self, net_enc, net_dec, labeldata, loss_scale=None): + super(SegmentationModule, self).__init__() + self.encoder = net_enc + self.decoder = net_dec + self.crit_dict = nn.ModuleDict() + if loss_scale is None: + self.loss_scale = {"object": 1, "part": 0.5, "scene": 0.25, "material": 1} + else: + self.loss_scale = loss_scale + + # criterion + self.crit_dict["object"] = nn.NLLLoss(ignore_index=0) # ignore background 0 + self.crit_dict["material"] = nn.NLLLoss(ignore_index=0) # ignore background 0 + self.crit_dict["scene"] = nn.NLLLoss(ignore_index=-1) # ignore unlabelled -1 + + # Label data - read from json + self.labeldata = labeldata + object_to_num = {k: v for v, k in enumerate(labeldata['object'])} + part_to_num = {k: v for v, k in enumerate(labeldata['part'])} + self.object_part = {object_to_num[k]: + [part_to_num[p] for p in v] + for k, v in labeldata['object_part'].items()} + self.object_with_part = sorted(self.object_part.keys()) + self.decoder.object_part = self.object_part + self.decoder.object_with_part = self.object_with_part + + def forward(self, feed_dict, *, seg_size=None): + if seg_size is None: # training + + if feed_dict['source_idx'] == 0: + output_switch = {"object": True, "part": True, "scene": True, "material": False} + elif feed_dict['source_idx'] == 1: + output_switch = {"object": False, "part": False, "scene": False, "material": True} + else: + raise ValueError + + pred = self.decoder( + self.encoder(feed_dict['img'], return_feature_maps=True), + output_switch=output_switch + ) + + # loss + loss_dict = {} + if pred['object'] is not None: # object + loss_dict['object'] = self.crit_dict['object'](pred['object'], feed_dict['seg_object']) + if pred['part'] is not None: # part + part_loss = 0 + for idx_part, object_label in enumerate(self.object_with_part): + part_loss += self.part_loss( + pred['part'][idx_part], feed_dict['seg_part'], + feed_dict['seg_object'], object_label, feed_dict['valid_part'][:, idx_part]) + loss_dict['part'] = part_loss + if pred['scene'] is not None: # scene + loss_dict['scene'] = self.crit_dict['scene'](pred['scene'], feed_dict['scene_label']) + if pred['material'] is not None: # material + loss_dict['material'] = self.crit_dict['material'](pred['material'], feed_dict['seg_material']) + loss_dict['total'] = sum([loss_dict[k] * self.loss_scale[k] for k in loss_dict.keys()]) + + # metric + metric_dict= {} + if pred['object'] is not None: + metric_dict['object'] = self.pixel_acc( + pred['object'], feed_dict['seg_object'], ignore_index=0) + if pred['material'] is not None: + metric_dict['material'] = self.pixel_acc( + pred['material'], feed_dict['seg_material'], ignore_index=0) + if pred['part'] is not None: + acc_sum, pixel_sum = 0, 0 + for idx_part, object_label in enumerate(self.object_with_part): + acc, pixel = self.part_pixel_acc( + pred['part'][idx_part], feed_dict['seg_part'], feed_dict['seg_object'], + object_label, feed_dict['valid_part'][:, idx_part]) + acc_sum += acc + pixel_sum += pixel + metric_dict['part'] = acc_sum.float() / (pixel_sum.float() + 1e-10) + if pred['scene'] is not None: + metric_dict['scene'] = self.pixel_acc( + pred['scene'], feed_dict['scene_label'], ignore_index=-1) + + return {'metric': metric_dict, 'loss': loss_dict} + else: # inference + output_switch = {"object": True, "part": True, "scene": True, "material": True} + pred = self.decoder(self.encoder(feed_dict['img'], return_feature_maps=True), + output_switch=output_switch, seg_size=seg_size) + return pred + + +def conv3x3(in_planes, out_planes, stride=1, has_bias=False): + "3x3 convolution with padding" + return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride, + padding=1, bias=has_bias) + + +def conv3x3_bn_relu(in_planes, out_planes, stride=1): + return nn.Sequential( + conv3x3(in_planes, out_planes, stride), + SynchronizedBatchNorm2d(out_planes), + nn.ReLU(inplace=True), + ) + + +class ModelBuilder: + def __init__(self): + pass + + # custom weights initialization + @staticmethod + def weights_init(m): + classname = m.__class__.__name__ + if classname.find('Conv') != -1: + nn.init.kaiming_normal_(m.weight.data, nonlinearity='relu') + elif classname.find('BatchNorm') != -1: + m.weight.data.fill_(1.) + m.bias.data.fill_(1e-4) + #elif classname.find('Linear') != -1: + # m.weight.data.normal_(0.0, 0.0001) + + def build_encoder(self, arch='resnet50_dilated8', fc_dim=512, weights=''): + pretrained = True if len(weights) == 0 else False + if arch == 'resnet34': + raise NotImplementedError + orig_resnet = resnet.__dict__['resnet34'](pretrained=pretrained) + net_encoder = Resnet(orig_resnet) + elif arch == 'resnet34_dilated8': + raise NotImplementedError + orig_resnet = resnet.__dict__['resnet34'](pretrained=pretrained) + net_encoder = ResnetDilated(orig_resnet, + dilate_scale=8) + elif arch == 'resnet34_dilated16': + raise NotImplementedError + orig_resnet = resnet.__dict__['resnet34'](pretrained=pretrained) + net_encoder = ResnetDilated(orig_resnet, + dilate_scale=16) + elif arch == 'resnet50': + orig_resnet = resnet.__dict__['resnet50'](pretrained=pretrained) + net_encoder = Resnet(orig_resnet) + elif arch == 'resnet101': + orig_resnet = resnet.__dict__['resnet101'](pretrained=pretrained) + net_encoder = Resnet(orig_resnet) + elif arch == 'resnext101': + orig_resnext = resnext.__dict__['resnext101'](pretrained=pretrained) + net_encoder = Resnet(orig_resnext) # we can still use class Resnet + else: + raise Exception('Architecture undefined!') + + # net_encoder.apply(self.weights_init) + if len(weights) > 0: + # print('Loading weights for net_encoder') + net_encoder.load_state_dict( + torch.load(weights, map_location=lambda storage, loc: storage), strict=False) + return net_encoder + + def build_decoder(self, nr_classes, + arch='ppm_bilinear_deepsup', fc_dim=512, + weights='', use_softmax=False): + if arch == 'upernet_lite': + net_decoder = UPerNet( + nr_classes=nr_classes, + fc_dim=fc_dim, + use_softmax=use_softmax, + fpn_dim=256) + elif arch == 'upernet': + net_decoder = UPerNet( + nr_classes=nr_classes, + fc_dim=fc_dim, + use_softmax=use_softmax, + fpn_dim=512) + else: + raise Exception('Architecture undefined!') + + net_decoder.apply(self.weights_init) + if len(weights) > 0: + # print('Loading weights for net_decoder') + net_decoder.load_state_dict( + torch.load(weights, map_location=lambda storage, loc: storage), strict=False) + return net_decoder + + +class Resnet(nn.Module): + def __init__(self, orig_resnet): + super(Resnet, self).__init__() + + # take pretrained resnet, except AvgPool and FC + self.conv1 = orig_resnet.conv1 + self.bn1 = orig_resnet.bn1 + self.relu1 = orig_resnet.relu1 + self.conv2 = orig_resnet.conv2 + self.bn2 = orig_resnet.bn2 + self.relu2 = orig_resnet.relu2 + self.conv3 = orig_resnet.conv3 + self.bn3 = orig_resnet.bn3 + self.relu3 = orig_resnet.relu3 + self.maxpool = orig_resnet.maxpool + self.layer1 = orig_resnet.layer1 + self.layer2 = orig_resnet.layer2 + self.layer3 = orig_resnet.layer3 + self.layer4 = orig_resnet.layer4 + + def forward(self, x, return_feature_maps=False): + conv_out = [] + + x = self.relu1(self.bn1(self.conv1(x))) + x = self.relu2(self.bn2(self.conv2(x))) + x = self.relu3(self.bn3(self.conv3(x))) + x = self.maxpool(x) + + x = self.layer1(x); conv_out.append(x); + x = self.layer2(x); conv_out.append(x); + x = self.layer3(x); conv_out.append(x); + x = self.layer4(x); conv_out.append(x); + + if return_feature_maps: + return conv_out + return [x] + + +# upernet +class UPerNet(nn.Module): + def __init__(self, nr_classes, fc_dim=4096, + use_softmax=False, pool_scales=(1, 2, 3, 6), + fpn_inplanes=(256,512,1024,2048), fpn_dim=256): + # Lazy import so that compilation isn't needed if not being used. + from .prroi_pool import PrRoIPool2D + super(UPerNet, self).__init__() + self.use_softmax = use_softmax + + # PPM Module + self.ppm_pooling = [] + self.ppm_conv = [] + + for scale in pool_scales: + # we use the feature map size instead of input image size, so down_scale = 1.0 + self.ppm_pooling.append(PrRoIPool2D(scale, scale, 1.)) + self.ppm_conv.append(nn.Sequential( + nn.Conv2d(fc_dim, 512, kernel_size=1, bias=False), + SynchronizedBatchNorm2d(512), + nn.ReLU(inplace=True) + )) + self.ppm_pooling = nn.ModuleList(self.ppm_pooling) + self.ppm_conv = nn.ModuleList(self.ppm_conv) + self.ppm_last_conv = conv3x3_bn_relu(fc_dim + len(pool_scales)*512, fpn_dim, 1) + + # FPN Module + self.fpn_in = [] + for fpn_inplane in fpn_inplanes[:-1]: # skip the top layer + self.fpn_in.append(nn.Sequential( + nn.Conv2d(fpn_inplane, fpn_dim, kernel_size=1, bias=False), + SynchronizedBatchNorm2d(fpn_dim), + nn.ReLU(inplace=True) + )) + self.fpn_in = nn.ModuleList(self.fpn_in) + + self.fpn_out = [] + for i in range(len(fpn_inplanes) - 1): # skip the top layer + self.fpn_out.append(nn.Sequential( + conv3x3_bn_relu(fpn_dim, fpn_dim, 1), + )) + self.fpn_out = nn.ModuleList(self.fpn_out) + + self.conv_fusion = conv3x3_bn_relu(len(fpn_inplanes) * fpn_dim, fpn_dim, 1) + + # background included. if ignore in loss, output channel 0 will not be trained. + self.nr_scene_class, self.nr_object_class, self.nr_part_class, self.nr_material_class = \ + nr_classes['scene'], nr_classes['object'], nr_classes['part'], nr_classes['material'] + + # input: PPM out, input_dim: fpn_dim + self.scene_head = nn.Sequential( + conv3x3_bn_relu(fpn_dim, fpn_dim, 1), + nn.AdaptiveAvgPool2d(1), + nn.Conv2d(fpn_dim, self.nr_scene_class, kernel_size=1, bias=True) + ) + + # input: Fusion out, input_dim: fpn_dim + self.object_head = nn.Sequential( + conv3x3_bn_relu(fpn_dim, fpn_dim, 1), + nn.Conv2d(fpn_dim, self.nr_object_class, kernel_size=1, bias=True) + ) + + # input: Fusion out, input_dim: fpn_dim + self.part_head = nn.Sequential( + conv3x3_bn_relu(fpn_dim, fpn_dim, 1), + nn.Conv2d(fpn_dim, self.nr_part_class, kernel_size=1, bias=True) + ) + + # input: FPN_2 (P2), input_dim: fpn_dim + self.material_head = nn.Sequential( + conv3x3_bn_relu(fpn_dim, fpn_dim, 1), + nn.Conv2d(fpn_dim, self.nr_material_class, kernel_size=1, bias=True) + ) + + def forward(self, conv_out, output_switch=None, seg_size=None): + + output_dict = {k: None for k in output_switch.keys()} + + conv5 = conv_out[-1] + input_size = conv5.size() + ppm_out = [conv5] + roi = [] # fake rois, just used for pooling + for i in range(input_size[0]): # batch size + roi.append(torch.Tensor([i, 0, 0, input_size[3], input_size[2]]).view(1, -1)) # b, x0, y0, x1, y1 + roi = torch.cat(roi, dim=0).type_as(conv5) + ppm_out = [conv5] + for pool_scale, pool_conv in zip(self.ppm_pooling, self.ppm_conv): + ppm_out.append(pool_conv(F.interpolate( + pool_scale(conv5, roi.detach()), + (input_size[2], input_size[3]), + mode='bilinear', align_corners=False))) + ppm_out = torch.cat(ppm_out, 1) + f = self.ppm_last_conv(ppm_out) + + if output_switch['scene']: # scene + output_dict['scene'] = self.scene_head(f) + + if output_switch['object'] or output_switch['part'] or output_switch['material']: + fpn_feature_list = [f] + for i in reversed(range(len(conv_out) - 1)): + conv_x = conv_out[i] + conv_x = self.fpn_in[i](conv_x) # lateral branch + + f = F.interpolate( + f, size=conv_x.size()[2:], mode='bilinear', align_corners=False) # top-down branch + f = conv_x + f + + fpn_feature_list.append(self.fpn_out[i](f)) + fpn_feature_list.reverse() # [P2 - P5] + + # material + if output_switch['material']: + output_dict['material'] = self.material_head(fpn_feature_list[0]) + + if output_switch['object'] or output_switch['part']: + output_size = fpn_feature_list[0].size()[2:] + fusion_list = [fpn_feature_list[0]] + for i in range(1, len(fpn_feature_list)): + fusion_list.append(F.interpolate( + fpn_feature_list[i], + output_size, + mode='bilinear', align_corners=False)) + fusion_out = torch.cat(fusion_list, 1) + x = self.conv_fusion(fusion_out) + + if output_switch['object']: # object + output_dict['object'] = self.object_head(x) + if output_switch['part']: + output_dict['part'] = self.part_head(x) + + if self.use_softmax: # is True during inference + # inference scene + x = output_dict['scene'] + x = x.squeeze(3).squeeze(2) + x = F.softmax(x, dim=1) + output_dict['scene'] = x + + # inference object, material + for k in ['object', 'material']: + x = output_dict[k] + x = F.interpolate(x, size=seg_size, mode='bilinear', align_corners=False) + x = F.softmax(x, dim=1) + output_dict[k] = x + + # inference part + x = output_dict['part'] + x = F.interpolate(x, size=seg_size, mode='bilinear', align_corners=False) + part_pred_list, head = [], 0 + for idx_part, object_label in enumerate(self.object_with_part): + n_part = len(self.object_part[object_label]) + _x = F.interpolate(x[:, head: head + n_part], size=seg_size, mode='bilinear', align_corners=False) + _x = F.softmax(_x, dim=1) + part_pred_list.append(_x) + head += n_part + output_dict['part'] = part_pred_list + + else: # Training + # object, scene, material + for k in ['object', 'scene', 'material']: + if output_dict[k] is None: + continue + x = output_dict[k] + x = F.log_softmax(x, dim=1) + if k == "scene": # for scene + x = x.squeeze(3).squeeze(2) + output_dict[k] = x + if output_dict['part'] is not None: + part_pred_list, head = [], 0 + for idx_part, object_label in enumerate(self.object_with_part): + n_part = len(self.object_part[object_label]) + x = output_dict['part'][:, head: head + n_part] + x = F.log_softmax(x, dim=1) + part_pred_list.append(x) + head += n_part + output_dict['part'] = part_pred_list + + return output_dict diff --git a/netdissect/upsegmodel/prroi_pool/.gitignore b/netdissect/upsegmodel/prroi_pool/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..18495eade007bad45f5ca772771d99f91e441e50 --- /dev/null +++ b/netdissect/upsegmodel/prroi_pool/.gitignore @@ -0,0 +1,2 @@ +*.o +/_prroi_pooling diff --git a/netdissect/upsegmodel/prroi_pool/README.md b/netdissect/upsegmodel/prroi_pool/README.md new file mode 100644 index 0000000000000000000000000000000000000000..bb98946d3b48a2069a58f179eb6da63e009c3849 --- /dev/null +++ b/netdissect/upsegmodel/prroi_pool/README.md @@ -0,0 +1,66 @@ +# PreciseRoIPooling +This repo implements the **Precise RoI Pooling** (PrRoI Pooling), proposed in the paper **Acquisition of Localization Confidence for Accurate Object Detection** published at ECCV 2018 (Oral Presentation). + +**Acquisition of Localization Confidence for Accurate Object Detection** + +_Borui Jiang*, Ruixuan Luo*, Jiayuan Mao*, Tete Xiao, Yuning Jiang_ (* indicates equal contribution.) + +https://arxiv.org/abs/1807.11590 + +## Brief + +In short, Precise RoI Pooling is an integration-based (bilinear interpolation) average pooling method for RoI Pooling. It avoids any quantization and has a continuous gradient on bounding box coordinates. It is: + +- different from the original RoI Pooling proposed in [Fast R-CNN](https://arxiv.org/abs/1504.08083). PrRoI Pooling uses average pooling instead of max pooling for each bin and has a continuous gradient on bounding box coordinates. That is, one can take the derivatives of some loss function w.r.t the coordinates of each RoI and optimize the RoI coordinates. +- different from the RoI Align proposed in [Mask R-CNN](https://arxiv.org/abs/1703.06870). PrRoI Pooling uses a full integration-based average pooling instead of sampling a constant number of points. This makes the gradient w.r.t. the coordinates continuous. + +For a better illustration, we illustrate RoI Pooling, RoI Align and PrRoI Pooing in the following figure. More details including the gradient computation can be found in our paper. + +
+ +## Implementation + +PrRoI Pooling was originally implemented by [Tete Xiao](http://tetexiao.com/) based on MegBrain, an (internal) deep learning framework built by Megvii Inc. It was later adapted into open-source deep learning frameworks. Currently, we only support PyTorch. Unfortunately, we don't have any specific plan for the adaptation into other frameworks such as TensorFlow, but any contributions (pull requests) will be more than welcome. + +## Usage (PyTorch 1.0) + +In the directory `pytorch/`, we provide a PyTorch-based implementation of PrRoI Pooling. It requires PyTorch 1.0+ and only supports CUDA (CPU mode is not implemented). +Since we use PyTorch JIT for cxx/cuda code compilation, to use the module in your code, simply do: + +``` +from prroi_pool import PrRoIPool2D + +avg_pool = PrRoIPool2D(window_height, window_width, spatial_scale) +roi_features = avg_pool(features, rois) + +# for those who want to use the "functional" + +from prroi_pool.functional import prroi_pool2d +roi_features = prroi_pool2d(features, rois, window_height, window_width, spatial_scale) +``` + + +## Usage (PyTorch 0.4) + +**!!! Please first checkout to the branch pytorch0.4.** + +In the directory `pytorch/`, we provide a PyTorch-based implementation of PrRoI Pooling. It requires PyTorch 0.4 and only supports CUDA (CPU mode is not implemented). +To use the PrRoI Pooling module, first goto `pytorch/prroi_pool` and execute `./travis.sh` to compile the essential components (you may need `nvcc` for this step). To use the module in your code, simply do: + +``` +from prroi_pool import PrRoIPool2D + +avg_pool = PrRoIPool2D(window_height, window_width, spatial_scale) +roi_features = avg_pool(features, rois) + +# for those who want to use the "functional" + +from prroi_pool.functional import prroi_pool2d +roi_features = prroi_pool2d(features, rois, window_height, window_width, spatial_scale) +``` + +Here, + +- RoI is an `m * 5` float tensor of format `(batch_index, x0, y0, x1, y1)`, following the convention in the original Caffe implementation of RoI Pooling, although in some frameworks the batch indices are provided by an integer tensor. +- `spatial_scale` is multiplied to the RoIs. For example, if your feature maps are down-sampled by a factor of 16 (w.r.t. the input image), you should use a spatial scale of `1/16`. +- The coordinates for RoI follows the [L, R) convension. That is, `(0, 0, 4, 4)` denotes a box of size `4x4`. diff --git a/netdissect/upsegmodel/prroi_pool/__init__.py b/netdissect/upsegmodel/prroi_pool/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..0c40b7a7e2bca8a0dbd28e13815f2f2ad6c4728b --- /dev/null +++ b/netdissect/upsegmodel/prroi_pool/__init__.py @@ -0,0 +1,13 @@ +#! /usr/bin/env python3 +# -*- coding: utf-8 -*- +# File : __init__.py +# Author : Jiayuan Mao, Tete Xiao +# Email : maojiayuan@gmail.com, jasonhsiao97@gmail.com +# Date : 07/13/2018 +# +# This file is part of PreciseRoIPooling. +# Distributed under terms of the MIT license. +# Copyright (c) 2017 Megvii Technology Limited. + +from .prroi_pool import * + diff --git a/netdissect/upsegmodel/prroi_pool/build.py b/netdissect/upsegmodel/prroi_pool/build.py new file mode 100644 index 0000000000000000000000000000000000000000..b198790817a2d11d65d6211b011f9408d9d34270 --- /dev/null +++ b/netdissect/upsegmodel/prroi_pool/build.py @@ -0,0 +1,50 @@ +#! /usr/bin/env python3 +# -*- coding: utf-8 -*- +# File : build.py +# Author : Jiayuan Mao, Tete Xiao +# Email : maojiayuan@gmail.com, jasonhsiao97@gmail.com +# Date : 07/13/2018 +# +# This file is part of PreciseRoIPooling. +# Distributed under terms of the MIT license. +# Copyright (c) 2017 Megvii Technology Limited. + +import os +import torch + +from torch.utils.ffi import create_extension + +headers = [] +sources = [] +defines = [] +extra_objects = [] +with_cuda = False + +if torch.cuda.is_available(): + with_cuda = True + + headers+= ['src/prroi_pooling_gpu.h'] + sources += ['src/prroi_pooling_gpu.c'] + defines += [('WITH_CUDA', None)] + + this_file = os.path.dirname(os.path.realpath(__file__)) + extra_objects_cuda = ['src/prroi_pooling_gpu_impl.cu.o'] + extra_objects_cuda = [os.path.join(this_file, fname) for fname in extra_objects_cuda] + extra_objects.extend(extra_objects_cuda) +else: + # TODO(Jiayuan Mao @ 07/13): remove this restriction after we support the cpu implementation. + raise NotImplementedError('Precise RoI Pooling only supports GPU (cuda) implememtations.') + +ffi = create_extension( + '_prroi_pooling', + headers=headers, + sources=sources, + define_macros=defines, + relative_to=__file__, + with_cuda=with_cuda, + extra_objects=extra_objects +) + +if __name__ == '__main__': + ffi.build() + diff --git a/netdissect/upsegmodel/prroi_pool/functional.py b/netdissect/upsegmodel/prroi_pool/functional.py new file mode 100644 index 0000000000000000000000000000000000000000..7dc7a8c282e846bd633c4fdc4190c4dca3da5a6f --- /dev/null +++ b/netdissect/upsegmodel/prroi_pool/functional.py @@ -0,0 +1,70 @@ +#! /usr/bin/env python3 +# -*- coding: utf-8 -*- +# File : functional.py +# Author : Jiayuan Mao, Tete Xiao +# Email : maojiayuan@gmail.com, jasonhsiao97@gmail.com +# Date : 07/13/2018 +# +# This file is part of PreciseRoIPooling. +# Distributed under terms of the MIT license. +# Copyright (c) 2017 Megvii Technology Limited. + +import torch +import torch.autograd as ag + +try: + from os.path import join as pjoin, dirname + from torch.utils.cpp_extension import load as load_extension + root_dir = pjoin(dirname(__file__), 'src') + _prroi_pooling = load_extension( + '_prroi_pooling', + [pjoin(root_dir, 'prroi_pooling_gpu.c'), pjoin(root_dir, 'prroi_pooling_gpu_impl.cu')], + verbose=False + ) +except ImportError: + raise ImportError('Can not compile Precise RoI Pooling library.') + +__all__ = ['prroi_pool2d'] + + +class PrRoIPool2DFunction(ag.Function): + @staticmethod + def forward(ctx, features, rois, pooled_height, pooled_width, spatial_scale): + assert 'FloatTensor' in features.type() and 'FloatTensor' in rois.type(), \ + 'Precise RoI Pooling only takes float input, got {} for features and {} for rois.'.format(features.type(), rois.type()) + + pooled_height = int(pooled_height) + pooled_width = int(pooled_width) + spatial_scale = float(spatial_scale) + + features = features.contiguous() + rois = rois.contiguous() + params = (pooled_height, pooled_width, spatial_scale) + + if features.is_cuda: + output = _prroi_pooling.prroi_pooling_forward_cuda(features, rois, *params) + ctx.params = params + # everything here is contiguous. + ctx.save_for_backward(features, rois, output) + else: + raise NotImplementedError('Precise RoI Pooling only supports GPU (cuda) implememtations.') + + return output + + @staticmethod + def backward(ctx, grad_output): + features, rois, output = ctx.saved_tensors + grad_input = grad_coor = None + + if features.requires_grad: + grad_output = grad_output.contiguous() + grad_input = _prroi_pooling.prroi_pooling_backward_cuda(features, rois, output, grad_output, *ctx.params) + if rois.requires_grad: + grad_output = grad_output.contiguous() + grad_coor = _prroi_pooling.prroi_pooling_coor_backward_cuda(features, rois, output, grad_output, *ctx.params) + + return grad_input, grad_coor, None, None, None + + +prroi_pool2d = PrRoIPool2DFunction.apply + diff --git a/netdissect/upsegmodel/prroi_pool/prroi_pool.py b/netdissect/upsegmodel/prroi_pool/prroi_pool.py new file mode 100644 index 0000000000000000000000000000000000000000..998b2b80531058fa91ac138e79ae39c5c0174601 --- /dev/null +++ b/netdissect/upsegmodel/prroi_pool/prroi_pool.py @@ -0,0 +1,28 @@ +#! /usr/bin/env python3 +# -*- coding: utf-8 -*- +# File : prroi_pool.py +# Author : Jiayuan Mao, Tete Xiao +# Email : maojiayuan@gmail.com, jasonhsiao97@gmail.com +# Date : 07/13/2018 +# +# This file is part of PreciseRoIPooling. +# Distributed under terms of the MIT license. +# Copyright (c) 2017 Megvii Technology Limited. + +import torch.nn as nn + +from .functional import prroi_pool2d + +__all__ = ['PrRoIPool2D'] + + +class PrRoIPool2D(nn.Module): + def __init__(self, pooled_height, pooled_width, spatial_scale): + super().__init__() + + self.pooled_height = int(pooled_height) + self.pooled_width = int(pooled_width) + self.spatial_scale = float(spatial_scale) + + def forward(self, features, rois): + return prroi_pool2d(features, rois, self.pooled_height, self.pooled_width, self.spatial_scale) diff --git a/netdissect/upsegmodel/prroi_pool/src/prroi_pooling_gpu.c b/netdissect/upsegmodel/prroi_pool/src/prroi_pooling_gpu.c new file mode 100644 index 0000000000000000000000000000000000000000..1e652963cdb76fe628d0a33bc270d2c25a0f3770 --- /dev/null +++ b/netdissect/upsegmodel/prroi_pool/src/prroi_pooling_gpu.c @@ -0,0 +1,113 @@ +/* + * File : prroi_pooling_gpu.c + * Author : Jiayuan Mao, Tete Xiao + * Email : maojiayuan@gmail.com, jasonhsiao97@gmail.com + * Date : 07/13/2018 + * + * Distributed under terms of the MIT license. + * Copyright (c) 2017 Megvii Technology Limited. + */ + +#include +#include + +#include +#include + +#include + +#include "prroi_pooling_gpu_impl.cuh" + + +at::Tensor prroi_pooling_forward_cuda(const at::Tensor &features, const at::Tensor &rois, int pooled_height, int pooled_width, float spatial_scale) { + int nr_rois = rois.size(0); + int nr_channels = features.size(1); + int height = features.size(2); + int width = features.size(3); + int top_count = nr_rois * nr_channels * pooled_height * pooled_width; + auto output = at::zeros({nr_rois, nr_channels, pooled_height, pooled_width}, features.options()); + + if (output.numel() == 0) { + THCudaCheck(cudaGetLastError()); + return output; + } + + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + PrRoIPoolingForwardGpu( + stream, features.data(), rois.data(), output.data(), + nr_channels, height, width, pooled_height, pooled_width, spatial_scale, + top_count + ); + + THCudaCheck(cudaGetLastError()); + return output; +} + +at::Tensor prroi_pooling_backward_cuda( + const at::Tensor &features, const at::Tensor &rois, const at::Tensor &output, const at::Tensor &output_diff, + int pooled_height, int pooled_width, float spatial_scale) { + + auto features_diff = at::zeros_like(features); + + int nr_rois = rois.size(0); + int batch_size = features.size(0); + int nr_channels = features.size(1); + int height = features.size(2); + int width = features.size(3); + int top_count = nr_rois * nr_channels * pooled_height * pooled_width; + int bottom_count = batch_size * nr_channels * height * width; + + if (output.numel() == 0) { + THCudaCheck(cudaGetLastError()); + return features_diff; + } + + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + PrRoIPoolingBackwardGpu( + stream, + features.data(), rois.data(), output.data(), output_diff.data(), + features_diff.data(), + nr_channels, height, width, pooled_height, pooled_width, spatial_scale, + top_count, bottom_count + ); + + THCudaCheck(cudaGetLastError()); + return features_diff; +} + +at::Tensor prroi_pooling_coor_backward_cuda( + const at::Tensor &features, const at::Tensor &rois, const at::Tensor &output, const at::Tensor &output_diff, + int pooled_height, int pooled_width, float spatial_scale) { + + auto coor_diff = at::zeros_like(rois); + + int nr_rois = rois.size(0); + int nr_channels = features.size(1); + int height = features.size(2); + int width = features.size(3); + int top_count = nr_rois * nr_channels * pooled_height * pooled_width; + int bottom_count = nr_rois * 5; + + if (output.numel() == 0) { + THCudaCheck(cudaGetLastError()); + return coor_diff; + } + + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + PrRoIPoolingCoorBackwardGpu( + stream, + features.data(), rois.data(), output.data(), output_diff.data(), + coor_diff.data(), + nr_channels, height, width, pooled_height, pooled_width, spatial_scale, + top_count, bottom_count + ); + + THCudaCheck(cudaGetLastError()); + return coor_diff; +} + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + m.def("prroi_pooling_forward_cuda", &prroi_pooling_forward_cuda, "PRRoIPooling_forward"); + m.def("prroi_pooling_backward_cuda", &prroi_pooling_backward_cuda, "PRRoIPooling_backward"); + m.def("prroi_pooling_coor_backward_cuda", &prroi_pooling_coor_backward_cuda, "PRRoIPooling_backward_coor"); +} diff --git a/netdissect/upsegmodel/prroi_pool/src/prroi_pooling_gpu.h b/netdissect/upsegmodel/prroi_pool/src/prroi_pooling_gpu.h new file mode 100644 index 0000000000000000000000000000000000000000..bc9d35181dd97c355fb6a5b17bc9e82e24ef1566 --- /dev/null +++ b/netdissect/upsegmodel/prroi_pool/src/prroi_pooling_gpu.h @@ -0,0 +1,22 @@ +/* + * File : prroi_pooling_gpu.h + * Author : Jiayuan Mao, Tete Xiao + * Email : maojiayuan@gmail.com, jasonhsiao97@gmail.com + * Date : 07/13/2018 + * + * Distributed under terms of the MIT license. + * Copyright (c) 2017 Megvii Technology Limited. + */ + +int prroi_pooling_forward_cuda(THCudaTensor *features, THCudaTensor *rois, THCudaTensor *output, int pooled_height, int pooled_width, float spatial_scale); + +int prroi_pooling_backward_cuda( + THCudaTensor *features, THCudaTensor *rois, THCudaTensor *output, THCudaTensor *output_diff, THCudaTensor *features_diff, + int pooled_height, int pooled_width, float spatial_scale +); + +int prroi_pooling_coor_backward_cuda( + THCudaTensor *features, THCudaTensor *rois, THCudaTensor *output, THCudaTensor *output_diff, THCudaTensor *features_diff, + int pooled_height, int pooled_width, float spatial_scal +); + diff --git a/netdissect/upsegmodel/prroi_pool/src/prroi_pooling_gpu_impl.cu b/netdissect/upsegmodel/prroi_pool/src/prroi_pooling_gpu_impl.cu new file mode 100644 index 0000000000000000000000000000000000000000..452b02055495ad721ba41b2708bccecc9b1aa2f3 --- /dev/null +++ b/netdissect/upsegmodel/prroi_pool/src/prroi_pooling_gpu_impl.cu @@ -0,0 +1,443 @@ +/* + * File : prroi_pooling_gpu_impl.cu + * Author : Tete Xiao, Jiayuan Mao + * Email : jasonhsiao97@gmail.com + * + * Distributed under terms of the MIT license. + * Copyright (c) 2017 Megvii Technology Limited. + */ + +#include "prroi_pooling_gpu_impl.cuh" + +#include +#include + +#define CUDA_KERNEL_LOOP(i, n) \ + for (int i = blockIdx.x * blockDim.x + threadIdx.x; \ + i < (n); \ + i += blockDim.x * gridDim.x) + +#define CUDA_POST_KERNEL_CHECK \ + do { \ + cudaError_t err = cudaGetLastError(); \ + if (cudaSuccess != err) { \ + fprintf(stderr, "cudaCheckError() failed : %s\n", cudaGetErrorString(err)); \ + exit(-1); \ + } \ + } while(0) + +#define CUDA_NUM_THREADS 512 + +namespace { + +static int CUDA_NUM_BLOCKS(const int N) { + return (N + CUDA_NUM_THREADS - 1) / CUDA_NUM_THREADS; +} + +__device__ static float PrRoIPoolingGetData(F_DEVPTR_IN data, const int h, const int w, const int height, const int width) +{ + bool overflow = (h < 0) || (w < 0) || (h >= height) || (w >= width); + float retVal = overflow ? 0.0f : data[h * width + w]; + return retVal; +} + +__device__ static float PrRoIPoolingGetCoeff(float dh, float dw){ + dw = dw > 0 ? dw : -dw; + dh = dh > 0 ? dh : -dh; + return (1.0f - dh) * (1.0f - dw); +} + +__device__ static float PrRoIPoolingSingleCoorIntegral(float s, float t, float c1, float c2) { + return 0.5 * (t * t - s * s) * c2 + (t - 0.5 * t * t - s + 0.5 * s * s) * c1; +} + +__device__ static float PrRoIPoolingInterpolation(F_DEVPTR_IN data, const float h, const float w, const int height, const int width){ + float retVal = 0.0f; + int h1 = floorf(h); + int w1 = floorf(w); + retVal += PrRoIPoolingGetData(data, h1, w1, height, width) * PrRoIPoolingGetCoeff(h - float(h1), w - float(w1)); + h1 = floorf(h)+1; + w1 = floorf(w); + retVal += PrRoIPoolingGetData(data, h1, w1, height, width) * PrRoIPoolingGetCoeff(h - float(h1), w - float(w1)); + h1 = floorf(h); + w1 = floorf(w)+1; + retVal += PrRoIPoolingGetData(data, h1, w1, height, width) * PrRoIPoolingGetCoeff(h - float(h1), w - float(w1)); + h1 = floorf(h)+1; + w1 = floorf(w)+1; + retVal += PrRoIPoolingGetData(data, h1, w1, height, width) * PrRoIPoolingGetCoeff(h - float(h1), w - float(w1)); + return retVal; +} + +__device__ static float PrRoIPoolingMatCalculation(F_DEVPTR_IN this_data, const int s_h, const int s_w, const int e_h, const int e_w, + const float y0, const float x0, const float y1, const float x1, const int h0, const int w0) +{ + float alpha, beta, lim_alpha, lim_beta, tmp; + float sum_out = 0; + + alpha = x0 - float(s_w); + beta = y0 - float(s_h); + lim_alpha = x1 - float(s_w); + lim_beta = y1 - float(s_h); + tmp = (lim_alpha - 0.5f * lim_alpha * lim_alpha - alpha + 0.5f * alpha * alpha) + * (lim_beta - 0.5f * lim_beta * lim_beta - beta + 0.5f * beta * beta); + sum_out += PrRoIPoolingGetData(this_data, s_h, s_w, h0, w0) * tmp; + + alpha = float(e_w) - x1; + lim_alpha = float(e_w) - x0; + tmp = (lim_alpha - 0.5f * lim_alpha * lim_alpha - alpha + 0.5f * alpha * alpha) + * (lim_beta - 0.5f * lim_beta * lim_beta - beta + 0.5f * beta * beta); + sum_out += PrRoIPoolingGetData(this_data, s_h, e_w, h0, w0) * tmp; + + alpha = x0 - float(s_w); + beta = float(e_h) - y1; + lim_alpha = x1 - float(s_w); + lim_beta = float(e_h) - y0; + tmp = (lim_alpha - 0.5f * lim_alpha * lim_alpha - alpha + 0.5f * alpha * alpha) + * (lim_beta - 0.5f * lim_beta * lim_beta - beta + 0.5f * beta * beta); + sum_out += PrRoIPoolingGetData(this_data, e_h, s_w, h0, w0) * tmp; + + alpha = float(e_w) - x1; + lim_alpha = float(e_w) - x0; + tmp = (lim_alpha - 0.5f * lim_alpha * lim_alpha - alpha + 0.5f * alpha * alpha) + * (lim_beta - 0.5f * lim_beta * lim_beta - beta + 0.5f * beta * beta); + sum_out += PrRoIPoolingGetData(this_data, e_h, e_w, h0, w0) * tmp; + + return sum_out; +} + +__device__ static void PrRoIPoolingDistributeDiff(F_DEVPTR_OUT diff, const float top_diff, const int h, const int w, const int height, const int width, const float coeff) +{ + bool overflow = (h < 0) || (w < 0) || (h >= height) || (w >= width); + if (!overflow) + atomicAdd(diff + h * width + w, top_diff * coeff); +} + +__device__ static void PrRoIPoolingMatDistributeDiff(F_DEVPTR_OUT diff, const float top_diff, const int s_h, const int s_w, const int e_h, const int e_w, + const float y0, const float x0, const float y1, const float x1, const int h0, const int w0) +{ + float alpha, beta, lim_alpha, lim_beta, tmp; + + alpha = x0 - float(s_w); + beta = y0 - float(s_h); + lim_alpha = x1 - float(s_w); + lim_beta = y1 - float(s_h); + tmp = (lim_alpha - 0.5f * lim_alpha * lim_alpha - alpha + 0.5f * alpha * alpha) + * (lim_beta - 0.5f * lim_beta * lim_beta - beta + 0.5f * beta * beta); + PrRoIPoolingDistributeDiff(diff, top_diff, s_h, s_w, h0, w0, tmp); + + alpha = float(e_w) - x1; + lim_alpha = float(e_w) - x0; + tmp = (lim_alpha - 0.5f * lim_alpha * lim_alpha - alpha + 0.5f * alpha * alpha) + * (lim_beta - 0.5f * lim_beta * lim_beta - beta + 0.5f * beta * beta); + PrRoIPoolingDistributeDiff(diff, top_diff, s_h, e_w, h0, w0, tmp); + + alpha = x0 - float(s_w); + beta = float(e_h) - y1; + lim_alpha = x1 - float(s_w); + lim_beta = float(e_h) - y0; + tmp = (lim_alpha - 0.5f * lim_alpha * lim_alpha - alpha + 0.5f * alpha * alpha) + * (lim_beta - 0.5f * lim_beta * lim_beta - beta + 0.5f * beta * beta); + PrRoIPoolingDistributeDiff(diff, top_diff, e_h, s_w, h0, w0, tmp); + + alpha = float(e_w) - x1; + lim_alpha = float(e_w) - x0; + tmp = (lim_alpha - 0.5f * lim_alpha * lim_alpha - alpha + 0.5f * alpha * alpha) + * (lim_beta - 0.5f * lim_beta * lim_beta - beta + 0.5f * beta * beta); + PrRoIPoolingDistributeDiff(diff, top_diff, e_h, e_w, h0, w0, tmp); +} + +__global__ void PrRoIPoolingForward( + const int nthreads, + F_DEVPTR_IN bottom_data, + F_DEVPTR_IN bottom_rois, + F_DEVPTR_OUT top_data, + const int channels, + const int height, + const int width, + const int pooled_height, + const int pooled_width, + const float spatial_scale) { + + CUDA_KERNEL_LOOP(index, nthreads) { + // (n, c, ph, pw) is an element in the pooled output + int pw = index % pooled_width; + int ph = (index / pooled_width) % pooled_height; + int c = (index / pooled_width / pooled_height) % channels; + int n = index / pooled_width / pooled_height / channels; + + bottom_rois += n * 5; + int roi_batch_ind = bottom_rois[0]; + + float roi_start_w = bottom_rois[1] * spatial_scale; + float roi_start_h = bottom_rois[2] * spatial_scale; + float roi_end_w = bottom_rois[3] * spatial_scale; + float roi_end_h = bottom_rois[4] * spatial_scale; + + float roi_width = max(roi_end_w - roi_start_w, ((float)0.0)); + float roi_height = max(roi_end_h - roi_start_h, ((float)0.0)); + float bin_size_h = roi_height / static_cast(pooled_height); + float bin_size_w = roi_width / static_cast(pooled_width); + + const float *this_data = bottom_data + (roi_batch_ind * channels + c) * height * width; + float *this_out = top_data + index; + + float win_start_w = roi_start_w + bin_size_w * pw; + float win_start_h = roi_start_h + bin_size_h * ph; + float win_end_w = win_start_w + bin_size_w; + float win_end_h = win_start_h + bin_size_h; + + float win_size = max(float(0.0), bin_size_w * bin_size_h); + if (win_size == 0) { + *this_out = 0; + return; + } + + float sum_out = 0; + + int s_w, s_h, e_w, e_h; + + s_w = floorf(win_start_w); + e_w = ceilf(win_end_w); + s_h = floorf(win_start_h); + e_h = ceilf(win_end_h); + + for (int w_iter = s_w; w_iter < e_w; ++w_iter) + for (int h_iter = s_h; h_iter < e_h; ++h_iter) + sum_out += PrRoIPoolingMatCalculation(this_data, h_iter, w_iter, h_iter + 1, w_iter + 1, + max(win_start_h, float(h_iter)), max(win_start_w, float(w_iter)), + min(win_end_h, float(h_iter) + 1.0), min(win_end_w, float(w_iter + 1.0)), + height, width); + *this_out = sum_out / win_size; + } +} + +__global__ void PrRoIPoolingBackward( + const int nthreads, + F_DEVPTR_IN bottom_rois, + F_DEVPTR_IN top_diff, + F_DEVPTR_OUT bottom_diff, + const int channels, + const int height, + const int width, + const int pooled_height, + const int pooled_width, + const float spatial_scale) { + + CUDA_KERNEL_LOOP(index, nthreads) { + // (n, c, ph, pw) is an element in the pooled output + int pw = index % pooled_width; + int ph = (index / pooled_width) % pooled_height; + int c = (index / pooled_width / pooled_height) % channels; + int n = index / pooled_width / pooled_height / channels; + bottom_rois += n * 5; + + int roi_batch_ind = bottom_rois[0]; + float roi_start_w = bottom_rois[1] * spatial_scale; + float roi_start_h = bottom_rois[2] * spatial_scale; + float roi_end_w = bottom_rois[3] * spatial_scale; + float roi_end_h = bottom_rois[4] * spatial_scale; + + float roi_width = max(roi_end_w - roi_start_w, (float)0); + float roi_height = max(roi_end_h - roi_start_h, (float)0); + float bin_size_h = roi_height / static_cast(pooled_height); + float bin_size_w = roi_width / static_cast(pooled_width); + + const float *this_out_grad = top_diff + index; + float *this_data_grad = bottom_diff + (roi_batch_ind * channels + c) * height * width; + + float win_start_w = roi_start_w + bin_size_w * pw; + float win_start_h = roi_start_h + bin_size_h * ph; + float win_end_w = win_start_w + bin_size_w; + float win_end_h = win_start_h + bin_size_h; + + float win_size = max(float(0.0), bin_size_w * bin_size_h); + + float sum_out = win_size == float(0) ? float(0) : *this_out_grad / win_size; + + int s_w, s_h, e_w, e_h; + + s_w = floorf(win_start_w); + e_w = ceilf(win_end_w); + s_h = floorf(win_start_h); + e_h = ceilf(win_end_h); + + for (int w_iter = s_w; w_iter < e_w; ++w_iter) + for (int h_iter = s_h; h_iter < e_h; ++h_iter) + PrRoIPoolingMatDistributeDiff(this_data_grad, sum_out, h_iter, w_iter, h_iter + 1, w_iter + 1, + max(win_start_h, float(h_iter)), max(win_start_w, float(w_iter)), + min(win_end_h, float(h_iter) + 1.0), min(win_end_w, float(w_iter + 1.0)), + height, width); + + } +} + +__global__ void PrRoIPoolingCoorBackward( + const int nthreads, + F_DEVPTR_IN bottom_data, + F_DEVPTR_IN bottom_rois, + F_DEVPTR_IN top_data, + F_DEVPTR_IN top_diff, + F_DEVPTR_OUT bottom_diff, + const int channels, + const int height, + const int width, + const int pooled_height, + const int pooled_width, + const float spatial_scale) { + + CUDA_KERNEL_LOOP(index, nthreads) { + // (n, c, ph, pw) is an element in the pooled output + int pw = index % pooled_width; + int ph = (index / pooled_width) % pooled_height; + int c = (index / pooled_width / pooled_height) % channels; + int n = index / pooled_width / pooled_height / channels; + bottom_rois += n * 5; + + int roi_batch_ind = bottom_rois[0]; + float roi_start_w = bottom_rois[1] * spatial_scale; + float roi_start_h = bottom_rois[2] * spatial_scale; + float roi_end_w = bottom_rois[3] * spatial_scale; + float roi_end_h = bottom_rois[4] * spatial_scale; + + float roi_width = max(roi_end_w - roi_start_w, (float)0); + float roi_height = max(roi_end_h - roi_start_h, (float)0); + float bin_size_h = roi_height / static_cast(pooled_height); + float bin_size_w = roi_width / static_cast(pooled_width); + + const float *this_out_grad = top_diff + index; + const float *this_bottom_data = bottom_data + (roi_batch_ind * channels + c) * height * width; + const float *this_top_data = top_data + index; + float *this_data_grad = bottom_diff + n * 5; + + float win_start_w = roi_start_w + bin_size_w * pw; + float win_start_h = roi_start_h + bin_size_h * ph; + float win_end_w = win_start_w + bin_size_w; + float win_end_h = win_start_h + bin_size_h; + + float win_size = max(float(0.0), bin_size_w * bin_size_h); + + float sum_out = win_size == float(0) ? float(0) : *this_out_grad / win_size; + + // WARNING: to be discussed + if (sum_out == 0) + return; + + int s_w, s_h, e_w, e_h; + + s_w = floorf(win_start_w); + e_w = ceilf(win_end_w); + s_h = floorf(win_start_h); + e_h = ceilf(win_end_h); + + float g_x1_y = 0, g_x2_y = 0, g_x_y1 = 0, g_x_y2 = 0; + for (int h_iter = s_h; h_iter < e_h; ++h_iter) { + g_x1_y += PrRoIPoolingSingleCoorIntegral(max(win_start_h, float(h_iter)) - h_iter, + min(win_end_h, float(h_iter + 1)) - h_iter, + PrRoIPoolingInterpolation(this_bottom_data, h_iter, win_start_w, height, width), + PrRoIPoolingInterpolation(this_bottom_data, h_iter + 1, win_start_w, height, width)); + + g_x2_y += PrRoIPoolingSingleCoorIntegral(max(win_start_h, float(h_iter)) - h_iter, + min(win_end_h, float(h_iter + 1)) - h_iter, + PrRoIPoolingInterpolation(this_bottom_data, h_iter, win_end_w, height, width), + PrRoIPoolingInterpolation(this_bottom_data, h_iter + 1, win_end_w, height, width)); + } + + for (int w_iter = s_w; w_iter < e_w; ++w_iter) { + g_x_y1 += PrRoIPoolingSingleCoorIntegral(max(win_start_w, float(w_iter)) - w_iter, + min(win_end_w, float(w_iter + 1)) - w_iter, + PrRoIPoolingInterpolation(this_bottom_data, win_start_h, w_iter, height, width), + PrRoIPoolingInterpolation(this_bottom_data, win_start_h, w_iter + 1, height, width)); + + g_x_y2 += PrRoIPoolingSingleCoorIntegral(max(win_start_w, float(w_iter)) - w_iter, + min(win_end_w, float(w_iter + 1)) - w_iter, + PrRoIPoolingInterpolation(this_bottom_data, win_end_h, w_iter, height, width), + PrRoIPoolingInterpolation(this_bottom_data, win_end_h, w_iter + 1, height, width)); + } + + float partial_x1 = -g_x1_y + (win_end_h - win_start_h) * (*this_top_data); + float partial_y1 = -g_x_y1 + (win_end_w - win_start_w) * (*this_top_data); + float partial_x2 = g_x2_y - (win_end_h - win_start_h) * (*this_top_data); + float partial_y2 = g_x_y2 - (win_end_w - win_start_w) * (*this_top_data); + + partial_x1 = partial_x1 / win_size * spatial_scale; + partial_x2 = partial_x2 / win_size * spatial_scale; + partial_y1 = partial_y1 / win_size * spatial_scale; + partial_y2 = partial_y2 / win_size * spatial_scale; + + // (b, x1, y1, x2, y2) + + this_data_grad[0] = 0; + atomicAdd(this_data_grad + 1, (partial_x1 * (1.0 - float(pw) / pooled_width) + partial_x2 * (1.0 - float(pw + 1) / pooled_width)) + * (*this_out_grad)); + atomicAdd(this_data_grad + 2, (partial_y1 * (1.0 - float(ph) / pooled_height) + partial_y2 * (1.0 - float(ph + 1) / pooled_height)) + * (*this_out_grad)); + atomicAdd(this_data_grad + 3, (partial_x2 * float(pw + 1) / pooled_width + partial_x1 * float(pw) / pooled_width) + * (*this_out_grad)); + atomicAdd(this_data_grad + 4, (partial_y2 * float(ph + 1) / pooled_height + partial_y1 * float(ph) / pooled_height) + * (*this_out_grad)); + } +} + +} /* !anonymous namespace */ + +#ifdef __cplusplus +extern "C" { +#endif + +void PrRoIPoolingForwardGpu( + cudaStream_t stream, + F_DEVPTR_IN bottom_data, + F_DEVPTR_IN bottom_rois, + F_DEVPTR_OUT top_data, + const int channels_, const int height_, const int width_, + const int pooled_height_, const int pooled_width_, + const float spatial_scale_, + const int top_count) { + + PrRoIPoolingForward<<>>( + top_count, bottom_data, bottom_rois, top_data, + channels_, height_, width_, pooled_height_, pooled_width_, spatial_scale_); + + CUDA_POST_KERNEL_CHECK; +} + +void PrRoIPoolingBackwardGpu( + cudaStream_t stream, + F_DEVPTR_IN bottom_data, + F_DEVPTR_IN bottom_rois, + F_DEVPTR_IN top_data, + F_DEVPTR_IN top_diff, + F_DEVPTR_OUT bottom_diff, + const int channels_, const int height_, const int width_, + const int pooled_height_, const int pooled_width_, + const float spatial_scale_, + const int top_count, const int bottom_count) { + + cudaMemsetAsync(bottom_diff, 0, sizeof(float) * bottom_count, stream); + PrRoIPoolingBackward<<>>( + top_count, bottom_rois, top_diff, bottom_diff, + channels_, height_, width_, pooled_height_, pooled_width_, spatial_scale_); + CUDA_POST_KERNEL_CHECK; +} + +void PrRoIPoolingCoorBackwardGpu( + cudaStream_t stream, + F_DEVPTR_IN bottom_data, + F_DEVPTR_IN bottom_rois, + F_DEVPTR_IN top_data, + F_DEVPTR_IN top_diff, + F_DEVPTR_OUT bottom_diff, + const int channels_, const int height_, const int width_, + const int pooled_height_, const int pooled_width_, + const float spatial_scale_, + const int top_count, const int bottom_count) { + + cudaMemsetAsync(bottom_diff, 0, sizeof(float) * bottom_count, stream); + PrRoIPoolingCoorBackward<<>>( + top_count, bottom_data, bottom_rois, top_data, top_diff, bottom_diff, + channels_, height_, width_, pooled_height_, pooled_width_, spatial_scale_); + CUDA_POST_KERNEL_CHECK; +} + +} /* !extern "C" */ + diff --git a/netdissect/upsegmodel/prroi_pool/src/prroi_pooling_gpu_impl.cuh b/netdissect/upsegmodel/prroi_pool/src/prroi_pooling_gpu_impl.cuh new file mode 100644 index 0000000000000000000000000000000000000000..95ad56797ca6299ededf63718d742343f8dab8e7 --- /dev/null +++ b/netdissect/upsegmodel/prroi_pool/src/prroi_pooling_gpu_impl.cuh @@ -0,0 +1,59 @@ +/* + * File : prroi_pooling_gpu_impl.cuh + * Author : Tete Xiao, Jiayuan Mao + * Email : jasonhsiao97@gmail.com + * + * Distributed under terms of the MIT license. + * Copyright (c) 2017 Megvii Technology Limited. + */ + +#ifndef PRROI_POOLING_GPU_IMPL_CUH +#define PRROI_POOLING_GPU_IMPL_CUH + +#ifdef __cplusplus +extern "C" { +#endif + +#define F_DEVPTR_IN const float * +#define F_DEVPTR_OUT float * + +void PrRoIPoolingForwardGpu( + cudaStream_t stream, + F_DEVPTR_IN bottom_data, + F_DEVPTR_IN bottom_rois, + F_DEVPTR_OUT top_data, + const int channels_, const int height_, const int width_, + const int pooled_height_, const int pooled_width_, + const float spatial_scale_, + const int top_count); + +void PrRoIPoolingBackwardGpu( + cudaStream_t stream, + F_DEVPTR_IN bottom_data, + F_DEVPTR_IN bottom_rois, + F_DEVPTR_IN top_data, + F_DEVPTR_IN top_diff, + F_DEVPTR_OUT bottom_diff, + const int channels_, const int height_, const int width_, + const int pooled_height_, const int pooled_width_, + const float spatial_scale_, + const int top_count, const int bottom_count); + +void PrRoIPoolingCoorBackwardGpu( + cudaStream_t stream, + F_DEVPTR_IN bottom_data, + F_DEVPTR_IN bottom_rois, + F_DEVPTR_IN top_data, + F_DEVPTR_IN top_diff, + F_DEVPTR_OUT bottom_diff, + const int channels_, const int height_, const int width_, + const int pooled_height_, const int pooled_width_, + const float spatial_scale_, + const int top_count, const int bottom_count); + +#ifdef __cplusplus +} /* !extern "C" */ +#endif + +#endif /* !PRROI_POOLING_GPU_IMPL_CUH */ + diff --git a/netdissect/upsegmodel/prroi_pool/test_prroi_pooling2d.py b/netdissect/upsegmodel/prroi_pool/test_prroi_pooling2d.py new file mode 100644 index 0000000000000000000000000000000000000000..a29d92c80538f5550808dc51f92dcaf65cbd9fb0 --- /dev/null +++ b/netdissect/upsegmodel/prroi_pool/test_prroi_pooling2d.py @@ -0,0 +1,56 @@ +# -*- coding: utf-8 -*- +# File : test_prroi_pooling2d.py +# Author : Jiayuan Mao +# Email : maojiayuan@gmail.com +# Date : 18/02/2018 +# +# This file is part of Jacinle. + +import unittest + +import torch +import torch.nn as nn +import torch.nn.functional as F + +from jactorch.utils.unittest import TorchTestCase + +from prroi_pool import PrRoIPool2D + + +class TestPrRoIPool2D(TorchTestCase): + def test_forward(self): + pool = PrRoIPool2D(7, 7, spatial_scale=0.5) + features = torch.rand((4, 16, 24, 32)).cuda() + rois = torch.tensor([ + [0, 0, 0, 14, 14], + [1, 14, 14, 28, 28], + ]).float().cuda() + + out = pool(features, rois) + out_gold = F.avg_pool2d(features, kernel_size=2, stride=1) + + self.assertTensorClose(out, torch.stack(( + out_gold[0, :, :7, :7], + out_gold[1, :, 7:14, 7:14], + ), dim=0)) + + def test_backward_shapeonly(self): + pool = PrRoIPool2D(2, 2, spatial_scale=0.5) + + features = torch.rand((4, 2, 24, 32)).cuda() + rois = torch.tensor([ + [0, 0, 0, 4, 4], + [1, 14, 14, 18, 18], + ]).float().cuda() + features.requires_grad = rois.requires_grad = True + out = pool(features, rois) + + loss = out.sum() + loss.backward() + + self.assertTupleEqual(features.size(), features.grad.size()) + self.assertTupleEqual(rois.size(), rois.grad.size()) + + +if __name__ == '__main__': + unittest.main() diff --git a/netdissect/upsegmodel/resnet.py b/netdissect/upsegmodel/resnet.py new file mode 100644 index 0000000000000000000000000000000000000000..ea5fdf82fafa3058c5f00074d55fbb1e584d5865 --- /dev/null +++ b/netdissect/upsegmodel/resnet.py @@ -0,0 +1,235 @@ +import os +import sys +import torch +import torch.nn as nn +import math +try: + from lib.nn import SynchronizedBatchNorm2d +except ImportError: + from torch.nn import BatchNorm2d as SynchronizedBatchNorm2d + +try: + from urllib import urlretrieve +except ImportError: + from urllib.request import urlretrieve + + +__all__ = ['ResNet', 'resnet50', 'resnet101'] # resnet101 is coming soon! + + +model_urls = { + 'resnet50': 'http://sceneparsing.csail.mit.edu/model/pretrained_resnet/resnet50-imagenet.pth', + 'resnet101': 'http://sceneparsing.csail.mit.edu/model/pretrained_resnet/resnet101-imagenet.pth' +} + + +def conv3x3(in_planes, out_planes, stride=1): + "3x3 convolution with padding" + return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride, + padding=1, bias=False) + + +class BasicBlock(nn.Module): + expansion = 1 + + def __init__(self, inplanes, planes, stride=1, downsample=None): + super(BasicBlock, self).__init__() + self.conv1 = conv3x3(inplanes, planes, stride) + self.bn1 = SynchronizedBatchNorm2d(planes) + self.relu = nn.ReLU(inplace=True) + self.conv2 = conv3x3(planes, planes) + self.bn2 = SynchronizedBatchNorm2d(planes) + self.downsample = downsample + self.stride = stride + + def forward(self, x): + residual = x + + out = self.conv1(x) + out = self.bn1(out) + out = self.relu(out) + + out = self.conv2(out) + out = self.bn2(out) + + if self.downsample is not None: + residual = self.downsample(x) + + out += residual + out = self.relu(out) + + return out + + +class Bottleneck(nn.Module): + expansion = 4 + + def __init__(self, inplanes, planes, stride=1, downsample=None): + super(Bottleneck, self).__init__() + self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False) + self.bn1 = SynchronizedBatchNorm2d(planes) + self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride, + padding=1, bias=False) + self.bn2 = SynchronizedBatchNorm2d(planes) + self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False) + self.bn3 = SynchronizedBatchNorm2d(planes * 4) + self.relu = nn.ReLU(inplace=True) + self.downsample = downsample + self.stride = stride + + def forward(self, x): + residual = x + + out = self.conv1(x) + out = self.bn1(out) + out = self.relu(out) + + out = self.conv2(out) + out = self.bn2(out) + out = self.relu(out) + + out = self.conv3(out) + out = self.bn3(out) + + if self.downsample is not None: + residual = self.downsample(x) + + out += residual + out = self.relu(out) + + return out + + +class ResNet(nn.Module): + + def __init__(self, block, layers, num_classes=1000): + self.inplanes = 128 + super(ResNet, self).__init__() + self.conv1 = conv3x3(3, 64, stride=2) + self.bn1 = SynchronizedBatchNorm2d(64) + self.relu1 = nn.ReLU(inplace=True) + self.conv2 = conv3x3(64, 64) + self.bn2 = SynchronizedBatchNorm2d(64) + self.relu2 = nn.ReLU(inplace=True) + self.conv3 = conv3x3(64, 128) + self.bn3 = SynchronizedBatchNorm2d(128) + self.relu3 = nn.ReLU(inplace=True) + self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) + + self.layer1 = self._make_layer(block, 64, layers[0]) + self.layer2 = self._make_layer(block, 128, layers[1], stride=2) + self.layer3 = self._make_layer(block, 256, layers[2], stride=2) + self.layer4 = self._make_layer(block, 512, layers[3], stride=2) + self.avgpool = nn.AvgPool2d(7, stride=1) + self.fc = nn.Linear(512 * block.expansion, num_classes) + + for m in self.modules(): + if isinstance(m, nn.Conv2d): + n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels + m.weight.data.normal_(0, math.sqrt(2. / n)) + elif isinstance(m, SynchronizedBatchNorm2d): + m.weight.data.fill_(1) + m.bias.data.zero_() + + def _make_layer(self, block, planes, blocks, stride=1): + downsample = None + if stride != 1 or self.inplanes != planes * block.expansion: + downsample = nn.Sequential( + nn.Conv2d(self.inplanes, planes * block.expansion, + kernel_size=1, stride=stride, bias=False), + SynchronizedBatchNorm2d(planes * block.expansion), + ) + + layers = [] + layers.append(block(self.inplanes, planes, stride, downsample)) + self.inplanes = planes * block.expansion + for i in range(1, blocks): + layers.append(block(self.inplanes, planes)) + + return nn.Sequential(*layers) + + def forward(self, x): + x = self.relu1(self.bn1(self.conv1(x))) + x = self.relu2(self.bn2(self.conv2(x))) + x = self.relu3(self.bn3(self.conv3(x))) + x = self.maxpool(x) + + x = self.layer1(x) + x = self.layer2(x) + x = self.layer3(x) + x = self.layer4(x) + + x = self.avgpool(x) + x = x.view(x.size(0), -1) + x = self.fc(x) + + return x + +''' +def resnet18(pretrained=False, **kwargs): + """Constructs a ResNet-18 model. + + Args: + pretrained (bool): If True, returns a model pre-trained on Places + """ + model = ResNet(BasicBlock, [2, 2, 2, 2], **kwargs) + if pretrained: + model.load_state_dict(load_url(model_urls['resnet18'])) + return model + + +def resnet34(pretrained=False, **kwargs): + """Constructs a ResNet-34 model. + + Args: + pretrained (bool): If True, returns a model pre-trained on Places + """ + model = ResNet(BasicBlock, [3, 4, 6, 3], **kwargs) + if pretrained: + model.load_state_dict(load_url(model_urls['resnet34'])) + return model +''' + +def resnet50(pretrained=False, **kwargs): + """Constructs a ResNet-50 model. + + Args: + pretrained (bool): If True, returns a model pre-trained on Places + """ + model = ResNet(Bottleneck, [3, 4, 6, 3], **kwargs) + if pretrained: + model.load_state_dict(load_url(model_urls['resnet50']), strict=False) + return model + + +def resnet101(pretrained=False, **kwargs): + """Constructs a ResNet-101 model. + + Args: + pretrained (bool): If True, returns a model pre-trained on Places + """ + model = ResNet(Bottleneck, [3, 4, 23, 3], **kwargs) + if pretrained: + model.load_state_dict(load_url(model_urls['resnet101']), strict=False) + return model + +# def resnet152(pretrained=False, **kwargs): +# """Constructs a ResNet-152 model. +# +# Args: +# pretrained (bool): If True, returns a model pre-trained on Places +# """ +# model = ResNet(Bottleneck, [3, 8, 36, 3], **kwargs) +# if pretrained: +# model.load_state_dict(load_url(model_urls['resnet152'])) +# return model + +def load_url(url, model_dir='./pretrained', map_location=None): + if not os.path.exists(model_dir): + os.makedirs(model_dir) + filename = url.split('/')[-1] + cached_file = os.path.join(model_dir, filename) + if not os.path.exists(cached_file): + sys.stderr.write('Downloading: "{}" to {}\n'.format(url, cached_file)) + urlretrieve(url, cached_file) + return torch.load(cached_file, map_location=map_location) diff --git a/netdissect/upsegmodel/resnext.py b/netdissect/upsegmodel/resnext.py new file mode 100644 index 0000000000000000000000000000000000000000..4c618c9da5be17feb975833532e19474fca82dba --- /dev/null +++ b/netdissect/upsegmodel/resnext.py @@ -0,0 +1,183 @@ +import os +import sys +import torch +import torch.nn as nn +import math +try: + from lib.nn import SynchronizedBatchNorm2d +except ImportError: + from torch.nn import BatchNorm2d as SynchronizedBatchNorm2d + +try: + from urllib import urlretrieve +except ImportError: + from urllib.request import urlretrieve + + +__all__ = ['ResNeXt', 'resnext101'] # support resnext 101 + + +model_urls = { + #'resnext50': 'http://sceneparsing.csail.mit.edu/model/pretrained_resnet/resnext50-imagenet.pth', + 'resnext101': 'http://sceneparsing.csail.mit.edu/model/pretrained_resnet/resnext101-imagenet.pth' +} + + +def conv3x3(in_planes, out_planes, stride=1): + "3x3 convolution with padding" + return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride, + padding=1, bias=False) + + +class GroupBottleneck(nn.Module): + expansion = 2 + + def __init__(self, inplanes, planes, stride=1, groups=1, downsample=None): + super(GroupBottleneck, self).__init__() + self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False) + self.bn1 = SynchronizedBatchNorm2d(planes) + self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride, + padding=1, groups=groups, bias=False) + self.bn2 = SynchronizedBatchNorm2d(planes) + self.conv3 = nn.Conv2d(planes, planes * 2, kernel_size=1, bias=False) + self.bn3 = SynchronizedBatchNorm2d(planes * 2) + self.relu = nn.ReLU(inplace=True) + self.downsample = downsample + self.stride = stride + + def forward(self, x): + residual = x + + out = self.conv1(x) + out = self.bn1(out) + out = self.relu(out) + + out = self.conv2(out) + out = self.bn2(out) + out = self.relu(out) + + out = self.conv3(out) + out = self.bn3(out) + + if self.downsample is not None: + residual = self.downsample(x) + + out += residual + out = self.relu(out) + + return out + + +class ResNeXt(nn.Module): + + def __init__(self, block, layers, groups=32, num_classes=1000): + self.inplanes = 128 + super(ResNeXt, self).__init__() + self.conv1 = conv3x3(3, 64, stride=2) + self.bn1 = SynchronizedBatchNorm2d(64) + self.relu1 = nn.ReLU(inplace=True) + self.conv2 = conv3x3(64, 64) + self.bn2 = SynchronizedBatchNorm2d(64) + self.relu2 = nn.ReLU(inplace=True) + self.conv3 = conv3x3(64, 128) + self.bn3 = SynchronizedBatchNorm2d(128) + self.relu3 = nn.ReLU(inplace=True) + self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) + + self.layer1 = self._make_layer(block, 128, layers[0], groups=groups) + self.layer2 = self._make_layer(block, 256, layers[1], stride=2, groups=groups) + self.layer3 = self._make_layer(block, 512, layers[2], stride=2, groups=groups) + self.layer4 = self._make_layer(block, 1024, layers[3], stride=2, groups=groups) + self.avgpool = nn.AvgPool2d(7, stride=1) + self.fc = nn.Linear(1024 * block.expansion, num_classes) + + for m in self.modules(): + if isinstance(m, nn.Conv2d): + n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels // m.groups + m.weight.data.normal_(0, math.sqrt(2. / n)) + elif isinstance(m, SynchronizedBatchNorm2d): + m.weight.data.fill_(1) + m.bias.data.zero_() + + def _make_layer(self, block, planes, blocks, stride=1, groups=1): + downsample = None + if stride != 1 or self.inplanes != planes * block.expansion: + downsample = nn.Sequential( + nn.Conv2d(self.inplanes, planes * block.expansion, + kernel_size=1, stride=stride, bias=False), + SynchronizedBatchNorm2d(planes * block.expansion), + ) + + layers = [] + layers.append(block(self.inplanes, planes, stride, groups, downsample)) + self.inplanes = planes * block.expansion + for i in range(1, blocks): + layers.append(block(self.inplanes, planes, groups=groups)) + + return nn.Sequential(*layers) + + def forward(self, x): + x = self.relu1(self.bn1(self.conv1(x))) + x = self.relu2(self.bn2(self.conv2(x))) + x = self.relu3(self.bn3(self.conv3(x))) + x = self.maxpool(x) + + x = self.layer1(x) + x = self.layer2(x) + x = self.layer3(x) + x = self.layer4(x) + + x = self.avgpool(x) + x = x.view(x.size(0), -1) + x = self.fc(x) + + return x + + +''' +def resnext50(pretrained=False, **kwargs): + """Constructs a ResNet-50 model. + + Args: + pretrained (bool): If True, returns a model pre-trained on Places + """ + model = ResNeXt(GroupBottleneck, [3, 4, 6, 3], **kwargs) + if pretrained: + model.load_state_dict(load_url(model_urls['resnext50']), strict=False) + return model +''' + + +def resnext101(pretrained=False, **kwargs): + """Constructs a ResNet-101 model. + + Args: + pretrained (bool): If True, returns a model pre-trained on Places + """ + model = ResNeXt(GroupBottleneck, [3, 4, 23, 3], **kwargs) + if pretrained: + model.load_state_dict(load_url(model_urls['resnext101']), strict=False) + return model + + +# def resnext152(pretrained=False, **kwargs): +# """Constructs a ResNeXt-152 model. +# +# Args: +# pretrained (bool): If True, returns a model pre-trained on Places +# """ +# model = ResNeXt(GroupBottleneck, [3, 8, 36, 3], **kwargs) +# if pretrained: +# model.load_state_dict(load_url(model_urls['resnext152'])) +# return model + + +def load_url(url, model_dir='./pretrained', map_location=None): + if not os.path.exists(model_dir): + os.makedirs(model_dir) + filename = url.split('/')[-1] + cached_file = os.path.join(model_dir, filename) + if not os.path.exists(cached_file): + sys.stderr.write('Downloading: "{}" to {}\n'.format(url, cached_file)) + urlretrieve(url, cached_file) + return torch.load(cached_file, map_location=map_location) diff --git a/netdissect/workerpool.py b/netdissect/workerpool.py new file mode 100644 index 0000000000000000000000000000000000000000..fe79124ddc86d0e7251d9e1a5d1012e7165249e3 --- /dev/null +++ b/netdissect/workerpool.py @@ -0,0 +1,158 @@ +''' +WorkerPool and WorkerBase for handling the common problems in managing +a multiprocess pool of workers that aren't done by multiprocessing.Pool, +including setup with per-process state, debugging by putting the worker +on the main thread, and correct handling of unexpected errors, and ctrl-C. + +To use it, +1. Put the per-process setup and the per-task work in the + setup() and work() methods of your own WorkerBase subclass. +2. To prepare the process pool, instantiate a WorkerPool, passing your + subclass type as the first (worker) argument, as well as any setup keyword + arguments. The WorkerPool will instantiate one of your workers in each + worker process (passing in the setup arguments in those processes). + If debugging, the pool can have process_count=0 to force all the work + to be done immediately on the main thread; otherwise all the work + will be passed to other processes. +3. Whenever there is a new piece of work to distribute, call pool.add(*args). + The arguments will be queued and passed as worker.work(*args) to the + next available worker. +4. When all the work has been distributed, call pool.join() to wait for all + the work to complete and to finish and terminate all the worker processes. + When pool.join() returns, all the work will have been done. + +No arrangement is made to collect the results of the work: for example, +the return value of work() is ignored. If you need to collect the +results, use your own mechanism (filesystem, shared memory object, queue) +which can be distributed using setup arguments. +''' + +from multiprocessing import Process, Queue, cpu_count +import signal +import atexit +import sys + +class WorkerBase(Process): + ''' + Subclass this class and override its work() method (and optionally, + setup() as well) to define the units of work to be done in a process + worker in a woker pool. + ''' + def __init__(self, i, process_count, queue, initargs): + if process_count > 0: + # Make sure we ignore ctrl-C if we are not on main process. + signal.signal(signal.SIGINT, signal.SIG_IGN) + self.process_id = i + self.process_count = process_count + self.queue = queue + super(WorkerBase, self).__init__() + self.setup(**initargs) + def run(self): + # Do the work until None is dequeued + while True: + try: + work_batch = self.queue.get() + except (KeyboardInterrupt, SystemExit): + print('Exiting...') + break + if work_batch is None: + self.queue.put(None) # for another worker + return + self.work(*work_batch) + def setup(self, **initargs): + ''' + Override this method for any per-process initialization. + Keywoard args are passed from WorkerPool constructor. + ''' + pass + def work(self, *args): + ''' + Override this method for one-time initialization. + Args are passed from WorkerPool.add() arguments. + ''' + raise NotImplementedError('worker subclass needed') + +class WorkerPool(object): + ''' + Instantiate this object (passing a WorkerBase subclass type + as its first argument) to create a worker pool. Then call + pool.add(*args) to queue args to distribute to worker.work(*args), + and call pool.join() to wait for all the workers to complete. + ''' + def __init__(self, worker=WorkerBase, process_count=None, **initargs): + global active_pools + if process_count is None: + process_count = cpu_count() + if process_count == 0: + # zero process_count uses only main process, for debugging. + self.queue = None + self.processes = None + self.worker = worker(None, 0, None, initargs) + return + # Ctrl-C strategy: worker processes should ignore ctrl-C. Set + # this up to be inherited by child processes before forking. + original_sigint_handler = signal.signal(signal.SIGINT, signal.SIG_IGN) + active_pools[id(self)] = self + self.queue = Queue(maxsize=(process_count * 3)) + self.processes = None # Initialize before trying to construct workers + self.processes = [worker(i, process_count, self.queue, initargs) + for i in range(process_count)] + for p in self.processes: + p.start() + # The main process should handle ctrl-C. Restore this now. + signal.signal(signal.SIGINT, original_sigint_handler) + def add(self, *work_batch): + if self.queue is None: + if hasattr(self, 'worker'): + self.worker.work(*work_batch) + else: + print('WorkerPool shutting down.', file=sys.stderr) + else: + try: + # The queue can block if the work is so slow it gets full. + self.queue.put(work_batch) + except (KeyboardInterrupt, SystemExit): + # Handle ctrl-C if done while waiting for the queue. + self.early_terminate() + def join(self): + # End the queue, and wait for all worker processes to complete nicely. + if self.queue is not None: + self.queue.put(None) + for p in self.processes: + p.join() + self.queue = None + # Remove myself from the set of pools that need cleanup on shutdown. + try: + del active_pools[id(self)] + except: + pass + def early_terminate(self): + # When shutting down unexpectedly, first end the queue. + if self.queue is not None: + try: + self.queue.put_nowait(None) # Nonblocking put throws if full. + self.queue = None + except: + pass + # But then don't wait: just forcibly terminate workers. + if self.processes is not None: + for p in self.processes: + p.terminate() + self.processes = None + try: + del active_pools[id(self)] + except: + pass + def __del__(self): + if self.queue is not None: + print('ERROR: workerpool.join() not called!', file=sys.stderr) + self.join() + +# Error and ctrl-C handling: kill worker processes if the main process ends. +active_pools = {} +def early_terminate_pools(): + for _, pool in list(active_pools.items()): + pool.early_terminate() + +atexit.register(early_terminate_pools) + diff --git a/netdissect/zdataset.py b/netdissect/zdataset.py new file mode 100644 index 0000000000000000000000000000000000000000..eb085d83d676fa1e4b1f1b053dc6f1ba2ff35381 --- /dev/null +++ b/netdissect/zdataset.py @@ -0,0 +1,41 @@ +import os, torch, numpy +from torch.utils.data import TensorDataset + +def z_dataset_for_model(model, size=100, seed=1): + return TensorDataset(z_sample_for_model(model, size, seed)) + +def z_sample_for_model(model, size=100, seed=1): + # If the model is marked with an input shape, use it. + if hasattr(model, 'input_shape'): + sample = standard_z_sample(size, model.input_shape[1], seed=seed).view( + (size,) + model.input_shape[1:]) + return sample + # Examine first conv in model to determine input feature size. + first_layer = [c for c in model.modules() + if isinstance(c, (torch.nn.Conv2d, torch.nn.ConvTranspose2d, + torch.nn.Linear))][0] + # 4d input if convolutional, 2d input if first layer is linear. + if isinstance(first_layer, (torch.nn.Conv2d, torch.nn.ConvTranspose2d)): + sample = standard_z_sample( + size, first_layer.in_channels, seed=seed)[:,:,None,None] + else: + sample = standard_z_sample( + size, first_layer.in_features, seed=seed) + return sample + +def standard_z_sample(size, depth, seed=1, device=None): + ''' + Generate a standard set of random Z as a (size, z_dimension) tensor. + With the same random seed, it always returns the same z (e.g., + the first one is always the same regardless of the size.) + ''' + # Use numpy RandomState since it can be done deterministically + # without affecting global state + rng = numpy.random.RandomState(seed) + result = torch.from_numpy( + rng.standard_normal(size * depth) + .reshape(size, depth)).float() + if device is not None: + result = result.to(device) + return result + diff --git a/notebooks/.ipynb_checkpoints/Ganspace_colab-checkpoint.ipynb b/notebooks/.ipynb_checkpoints/Ganspace_colab-checkpoint.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..98ba2a5d0ad9507dbef94a860cbcd538a887a436 --- /dev/null +++ b/notebooks/.ipynb_checkpoints/Ganspace_colab-checkpoint.ipynb @@ -0,0 +1,1664 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "yyjPqusnkHHJ", + "outputId": "8a229ada-fd1c-424c-938f-e98b0cdac9df" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TensorFlow 1.x selected.\n" + ] + } + ], + "source": [ + "%tensorflow_version 1.x" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "lM2k1EDpBZFc" + }, + "outputs": [], + "source": [ + "#@title Mount Google Drive (Optional)\n", + "from google.colab import drive\n", + "drive.mount('/content/drive/', force_remount=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "W-gc95AN_wQ4" + }, + "source": [ + "\n", + "## Setup\n", + "Hit play on all the cells below, and everything should run smoothly. The install takes around half a minute.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "both", + "id": "04xop1hZISlG" + }, + "outputs": [], + "source": [ + "# Clone git\n", + "!git clone https://github.com/harskish/ganspace\n", + "%cd ganspace\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "dKCsAiNNFLnn" + }, + "outputs": [], + "source": [ + "#@title Install remaining packages\n", + "from IPython.display import Javascript\n", + "display(Javascript('''google.colab.output.setIframeHeight(0, true, {maxHeight: 200})'''))\n", + "!pip install fbpca boto3\n", + "!git submodule update --init --recursive\n", + "!python -c \"import nltk; nltk.download('wordnet')\"\n", + "\n", + "# Custom OPs no longer required\n", + "#!pip install Ninja\n", + "#%cd models/stylegan2/stylegan2-pytorch/op\n", + "#!python setup.py install\n", + "#!python -c \"import torch; import upfirdn2d_op; import fused; print('OK')\"\n", + "#%cd \"/content/ganspace\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jo8zwRspKJBb" + }, + "source": [ + "# Convert model weights\n", + "\n", + "If you have a tensorflow model you want to use Ganspace on - convert it to a pytorch model below.\n", + "\n", + "(skip this step if you already have a pytorch model)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "0c32G3UvnFaV" + }, + "outputs": [], + "source": [ + "!gdown --id 1UlDmJVLLnBD9SnLSMXeiZRO6g-OMQCA_ -O /content/ffhq.pkl" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "tQcivtikdOsC" + }, + "outputs": [], + "source": [ + "%cd \"/content\"\n", + "!git clone https://github.com/skyflynil/stylegan2\n", + "%cd ganspace" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tQPsNKq9n2pI" + }, + "source": [ + "The convert weight script takes two arguments: \n", + "\n", + "```\n", + "--repo - Path to tensorflow stylegan2 repo\n", + " - Path to your model\n", + "```\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Pdkk4vyXtrNh" + }, + "outputs": [], + "source": [ + "!python /content/ganspace/models/stylegan2/stylegan2-pytorch/convert_weight.py --repo=\"/content/stylegan2/\" \"/content/ffhq.pkl\" #convert weights" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "-pRwkojK1uP-" + }, + "outputs": [], + "source": [ + "!cp \"/content/ganspace/ffhq.pt\" \"/content/drive/My Drive/ML/stylegan_models\" #copy pytorch model to your drive" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vhVTzEZjrdFv" + }, + "source": [ + "# Run PCA Analysis" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "MRuvtoQhrt1J" + }, + "source": [ + "From here, open models/wrappers.py, and edit the stylegan2 configs dict on line 110 to include your model and its corresponding resolution.\n", + "\n", + "I.E from\n", + "\n", + " # Image widths\n", + " configs = {\n", + " 'ffhq': 1024,\n", + " 'car': 512,\n", + " 'cat': 256,\n", + " }\n", + "\n", + "to \n", + "\n", + " # Image widths\n", + " configs = {\n", + " 'your_model': your_resolution,\n", + " 'ffhq': 1024,\n", + " 'car': 512,\n", + " 'cat': 256,\n", + " }\n", + "\n", + "Then copy your pytorch model over to your drive account or any other hosting platform, and add the direct download link to the checkpoints dict in the download_checkpoint function on line 136.\n", + "\n", + " def download_checkpoint(self, outfile):\n", + " checkpoints = {\n", + " 'yourmodel': 'https://drive.google.com/yourmodel',\n", + " 'ffhq': 'https://drive.google.com/uc?id=12yYXZymadSIj74Yue1Q7RrlbIqrXggo3',\n", + " 'car': 'https://drive.google.com/uc?export=download&id=1iRoWclWVbDBAy5iXYZrQnKYSbZUqXI6y',\n", + " 'cat': 'https://drive.google.com/uc?export=download&id=15vJP8GDr0FlRYpE8gD7CdeEz2mXrQMgN',\n", + " }\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7GggN36LpSgo" + }, + "source": [ + "##Options\n", + "\n", + "\n", + "```\n", + "Command line paramaters:\n", + " --model one of [ProGAN, BigGAN-512, BigGAN-256, BigGAN-128, StyleGAN, StyleGAN2]\n", + " --class class name; leave empty to list options\n", + " --layer layer at which to perform PCA; leave empty to list options\n", + " --use_w treat W as the main latent space (StyleGAN / StyleGAN2)\n", + " --inputs load previously exported edits from directory\n", + " --sigma number of stdevs to use in visualize.py\n", + " -n number of PCA samples\n", + " -b override automatic minibatch size detection\n", + " -c number of components to keep\n", + "\n", + "```\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "AGTY0XmaIfz_" + }, + "outputs": [], + "source": [ + "%cd ../ganspace/" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "AglcMDAUt-mm" + }, + "outputs": [], + "source": [ + "model_name = 'StyleGAN2' \n", + "model_class = 'ffhq' #this is the name of your model in the configs\n", + "num_components = 80" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "both", + "id": "7RmHtfgdomsx" + }, + "outputs": [], + "source": [ + "#Check layers available for analysis by passing dummy name\n", + "!python visualize.py --model $model_name --class $model_class --use_w --layer=dummy_name" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "iwoyJLamjciq" + }, + "source": [ + "Add chosen layer in as --layer argument:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "D41v8w25l0j8" + }, + "outputs": [], + "source": [ + "!python visualize.py --model $model_name --class $model_class --use_w --layer=style -c $num_components" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "4uSCkh4OAqOU" + }, + "outputs": [], + "source": [ + "!python visualize.py --model=$model_name --class=$model_class --use_w --layer=\"style\" -b=500 --batch --video #add -video to generate videos" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "0Vf0BDQMIVPi" + }, + "outputs": [], + "source": [ + "!python visualize.py --model=StyleGAN2 --class=ffhq --use_w --layer=style -b=10000" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "JW_I1n1DMMEO" + }, + "outputs": [], + "source": [ + "!zip -r samples.zip \"/content/ganspace/out/StyleGAN2-ffhq\" #zip up samples for download" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "k9Oz_9TjuBPc" + }, + "outputs": [], + "source": [ + "%cp -r \"/content/ganspace/cache/components\" \"/content/drive/My Drive/ML/stylegan2/comps\" #copying components over to google drive" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "m7TDzlXCHe59" + }, + "source": [ + "# Explore Directions!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Y9_fWV-NpuLA" + }, + "source": [ + "After running visualize.py, your components will be stored in an npz file in /content/ganspace/cache/components/ - below the npz file is unpacked, and a component/direction is chosen at random. \n", + "\n", + "Using the UI, you can explore the latent direction and give it a name, which will be appeneded to the named_directions dictionary and saved as 'direction_name.npy' for later use.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "rD24fpCcHnyV" + }, + "outputs": [], + "source": [ + "# Load model\n", + "from IPython.utils import io\n", + "import torch\n", + "import PIL\n", + "import numpy as np\n", + "import ipywidgets as widgets\n", + "from PIL import Image\n", + "import imageio\n", + "from models import get_instrumented_model\n", + "from decomposition import get_or_compute\n", + "from config import Config\n", + "from skimage import img_as_ubyte\n", + "\n", + "# Speed up computation\n", + "torch.autograd.set_grad_enabled(False)\n", + "torch.backends.cudnn.benchmark = True\n", + "\n", + "# Specify model to use\n", + "config = Config(\n", + " model='StyleGAN2',\n", + " layer='style',\n", + " output_class='ffhq',\n", + " components=80,\n", + " use_w=True,\n", + " batch_size=5_000, # style layer quite small\n", + ")\n", + "\n", + "inst = get_instrumented_model(config.model, config.output_class,\n", + " config.layer, torch.device('cuda'), use_w=config.use_w)\n", + "\n", + "path_to_components = get_or_compute(config, inst)\n", + "\n", + "model = inst.model\n", + "\n", + "named_directions = {} #init named_directions dict to save directions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "E8NFoXruGy_C" + }, + "outputs": [], + "source": [ + "#@title Load a component at random\n", + "\n", + "comps = np.load(path_to_components)\n", + "lst = comps.files\n", + "latent_dirs = []\n", + "latent_stdevs = []\n", + "\n", + "load_activations = False\n", + "\n", + "for item in lst:\n", + " if load_activations:\n", + " if item == 'act_comp':\n", + " for i in range(comps[item].shape[0]):\n", + " latent_dirs.append(comps[item][i])\n", + " if item == 'act_stdev':\n", + " for i in range(comps[item].shape[0]):\n", + " latent_stdevs.append(comps[item][i])\n", + " else:\n", + " if item == 'lat_comp':\n", + " for i in range(comps[item].shape[0]):\n", + " latent_dirs.append(comps[item][i])\n", + " if item == 'lat_stdev':\n", + " for i in range(comps[item].shape[0]):\n", + " latent_stdevs.append(comps[item][i])\n", + " \n", + "#load one at random \n", + "num = np.random.randint(20)\n", + "if num in named_directions.values():\n", + " print(f'Direction already named: {list(named_directions.keys())[list(named_directions.values()).index(num)]}')\n", + "\n", + "random_dir = latent_dirs[num]\n", + "random_dir_stdev = latent_stdevs[num]\n", + "\n", + "print(f'Loaded Component No. {num}')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "cellView": "form", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 549, + "referenced_widgets": [ + "ae9f6667f56c44f193fdae884d60dcc2", + "7725eb04caa1491fb7da74a89f26908e", + "1e8fcebb631247578ba9aa39b6c765ff", + "7913abe6ab8b4e67828cfa5f32d244f4", + "b47793d0bac7465497b3a61881eb3831", + "70655d4b9050402194d000c0af617048", + "c0fc07533df7404f9369d8935f54a8b0", + "9dccffdade46497db2ec0f061236a3ff", + "64fa4df388f448839feac895d645f02b", + "8d75f788789e48009d51db574ac20b29", + "a19fe52cddb14a9dad0f549bc0154a2a", + "4aae134718d24c1d93a92d962113577a", + "fb79cfa871d54ac9a6d3c089f8f22eac", + "b6b598d128f749d184548abeafad1935", + "d82a4c82d6d5488a8567373b081a698c", + "933e21c96bb0403dbfdc737c5ddb2b0b", + "c0dd409781194e7f9bb8126571d4431d", + "2f51718dae6e4c4fb70ea28e91840467", + "8a6ee9d7641f4e1a803ab688bb04d085", + "bd3512aa9e61413eb7a6e7ba7707f0fa", + "996c259c47c644409c9b6c71b665e10c", + "06aaae9584fc4d39b8d2ab19ba2dde3e", + "ebb903320678435386c08c4e29c4b6ad", + "ae49fe727b8b4562b034196a364ae0dc", + "31cdd0993d464cababb6f220d8292c6e", + "9ac961362cfd42229daab07d0ed4f8bf", + "3dddcb7cf4d14d58b029cd8ccd1bd675" + ] + }, + "id": "wJytqjrVwZ7K", + "outputId": "86e1c66d-fac3-4310-d40c-e65953062c18" + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ae9f6667f56c44f193fdae884d60dcc2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HBox(children=(IntSlider(value=99782, continuous_update=False, description='Seed: ', max=100000…" + ] + }, + "metadata": { + "tags": [] + }, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9ac961362cfd42229daab07d0ed4f8bf", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Output()" + ] + }, + "metadata": { + "tags": [] + }, + "output_type": "display_data" + } + ], + "source": [ + "#@title Run UI (save component with Enter key)\n", + "from ipywidgets import fixed\n", + "\n", + "# Taken from https://github.com/alexanderkuk/log-progress\n", + "def log_progress(sequence, every=1, size=None, name='Items'):\n", + " from ipywidgets import IntProgress, HTML, VBox\n", + " from IPython.display import display\n", + "\n", + " is_iterator = False\n", + " if size is None:\n", + " try:\n", + " size = len(sequence)\n", + " except TypeError:\n", + " is_iterator = True\n", + " if size is not None:\n", + " if every is None:\n", + " if size <= 200:\n", + " every = 1\n", + " else:\n", + " every = int(size / 200) # every 0.5%\n", + " else:\n", + " assert every is not None, 'sequence is iterator, set every'\n", + "\n", + " if is_iterator:\n", + " progress = IntProgress(min=0, max=1, value=1)\n", + " progress.bar_style = 'info'\n", + " else:\n", + " progress = IntProgress(min=0, max=size, value=0)\n", + " label = HTML()\n", + " box = VBox(children=[label, progress])\n", + " display(box)\n", + "\n", + " index = 0\n", + " try:\n", + " for index, record in enumerate(sequence, 1):\n", + " if index == 1 or index % every == 0:\n", + " if is_iterator:\n", + " label.value = '{name}: {index} / ?'.format(\n", + " name=name,\n", + " index=index\n", + " )\n", + " else:\n", + " progress.value = index\n", + " label.value = u'{name}: {index} / {size}'.format(\n", + " name=name,\n", + " index=index,\n", + " size=size\n", + " )\n", + " yield record\n", + " except:\n", + " progress.bar_style = 'danger'\n", + " raise\n", + " else:\n", + " progress.bar_style = 'success'\n", + " progress.value = index\n", + " label.value = \"{name}: {index}\".format(\n", + " name=name,\n", + " index=str(index or '?')\n", + " )\n", + "\n", + "def name_direction(sender):\n", + " if not text.value:\n", + " print('Please name the direction before saving')\n", + " return\n", + " \n", + " if num in named_directions.values():\n", + " target_key = list(named_directions.keys())[list(named_directions.values()).index(num)]\n", + " print(f'Direction already named: {target_key}')\n", + " print(f'Overwriting... ')\n", + " del(named_directions[target_key])\n", + " named_directions[text.value] = [num, start_layer.value, end_layer.value]\n", + " save_direction(random_dir, text.value)\n", + " for item in named_directions:\n", + " print(item, named_directions[item])\n", + "\n", + "def save_direction(direction, filename):\n", + " filename += \".npy\"\n", + " np.save(filename, direction, allow_pickle=True, fix_imports=True)\n", + " print(f'Latent direction saved as {filename}')\n", + "\n", + "def display_sample_pytorch(seed, truncation, direction, distance, scale, start, end, disp=True, save=None, noise_spec=None):\n", + " # blockPrint()\n", + " with io.capture_output() as captured:\n", + " w = model.sample_latent(1, seed=seed).cpu().numpy()\n", + "\n", + " model.truncation = truncation\n", + " w = [w]*model.get_max_latents() # one per layer\n", + " for l in range(start, end):\n", + " w[l] = w[l] + direction * distance * scale\n", + "\n", + " #save image and display\n", + " out = model.sample_np(w)\n", + " final_im = Image.fromarray((out * 255).astype(np.uint8)).resize((500,500),Image.LANCZOS)\n", + "\n", + " if disp:\n", + " display(final_im)\n", + " if save is not None:\n", + " if disp == False:\n", + " print(save)\n", + " final_im.save(f'out/{seed}_{save:05}.png')\n", + "\n", + "def generate_mov(seed, truncation, direction_vec, scale, layers, n_frames, out_name = 'out', noise_spec = None, loop=True):\n", + " \"\"\"Generates a mov moving back and forth along the chosen direction vector\"\"\"\n", + " # Example of reading a generated set of images, and storing as MP4.\n", + " %mkdir out\n", + " movieName = f'out/{out_name}.mp4'\n", + " offset = -10\n", + " step = 20 / n_frames\n", + " imgs = []\n", + " for i in log_progress(range(n_frames), name = \"Generating frames\"):\n", + " print(f'\\r{i} / {n_frames}', end='')\n", + " w = model.sample_latent(1, seed=seed).cpu().numpy()\n", + "\n", + " model.truncation = truncation\n", + " w = [w]*model.get_max_latents() # one per layer\n", + " for l in layers:\n", + " if l <= model.get_max_latents():\n", + " w[l] = w[l] + direction_vec * offset * scale\n", + "\n", + " #save image and display\n", + " out = model.sample_np(w)\n", + " final_im = Image.fromarray((out * 255).astype(np.uint8))\n", + " imgs.append(out)\n", + " #increase offset\n", + " offset += step\n", + " if loop:\n", + " imgs += imgs[::-1]\n", + " with imageio.get_writer(movieName, mode='I') as writer:\n", + " for image in log_progress(list(imgs), name = \"Creating animation\"):\n", + " writer.append_data(img_as_ubyte(image))\n", + "\n", + "\n", + "seed = np.random.randint(0,100000)\n", + "style = {'description_width': 'initial'}\n", + "\n", + "seed = widgets.IntSlider(min=0, max=100000, step=1, value=seed, description='Seed: ', continuous_update=False)\n", + "truncation = widgets.FloatSlider(min=0, max=2, step=0.1, value=0.7, description='Truncation: ', continuous_update=False)\n", + "distance = widgets.FloatSlider(min=-10, max=10, step=0.1, value=0, description='Distance: ', continuous_update=False, style=style)\n", + "scale = widgets.FloatSlider(min=0, max=10, step=0.05, value=1, description='Scale: ', continuous_update=False)\n", + "start_layer = widgets.IntSlider(min=0, max=model.get_max_latents(), step=1, value=0, description='start layer: ', continuous_update=False)\n", + "end_layer = widgets.IntSlider(min=0, max=model.get_max_latents(), step=1, value=18, description='end layer: ', continuous_update=False)\n", + "\n", + "# Make sure layer range is valid\n", + "def update_range_start(*args):\n", + " end_layer.min = start_layer.value\n", + "def update_range_end(*args):\n", + " start_layer.max = end_layer.value\n", + "start_layer.observe(update_range_start, 'value')\n", + "end_layer.observe(update_range_end, 'value')\n", + "\n", + "text = widgets.Text(description=\"Name component here\", style=style, width=200)\n", + "\n", + "bot_box = widgets.HBox([seed, truncation, distance, scale, start_layer, end_layer, text])\n", + "ui = widgets.VBox([bot_box])\n", + "\n", + "out = widgets.interactive_output(display_sample_pytorch, {'seed': seed, 'truncation': truncation, 'direction': fixed(random_dir), 'distance': distance, 'scale': scale, 'start': start_layer, 'end': end_layer})\n", + "\n", + "display(ui, out)\n", + "text.on_submit(name_direction)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "zJjbP91dgQui" + }, + "outputs": [], + "source": [ + "#script to generate a movie moving back and forth along the direction\n", + "\n", + "direction_name = 'raise_eyebrows'\n", + "num_samples = 5\n", + "assert direction_name in named_directions, \\\n", + " f'\"{direction_name}\" not found, please save it first using the cell above.'\n", + "\n", + "loc = named_directions[direction_name][0]\n", + "for i in range(num_samples):\n", + " s = np.random.randint(0, 10000)\n", + " generate_mov(seed = s, truncation = 0.8, direction_vec = latent_dirs[loc], scale = 2, layers=range(named_directions[direction_name][1], named_directions[direction_name][2]), n_frames = 20, out_name = f'{model_class}_{direction_name}_{i}', loop=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "dDbfx6e09dTX" + }, + "outputs": [], + "source": [ + "#@title Select from named directions\n", + "\n", + "from IPython.display import display, clear_output\n", + "\n", + "vardict = list(named_directions.keys())\n", + "select_variable = widgets.Dropdown(\n", + " options=vardict,\n", + " value=vardict[0],\n", + " description='Select variable:',\n", + " disabled=False,\n", + " button_style=''\n", + ")\n", + "\n", + "def set_direction(b):\n", + " clear_output()\n", + " random_dir = latent_dirs[named_directions[select_variable.value][0]]\n", + " start_layer = named_directions[select_variable.value][1]\n", + " end_layer = named_directions[select_variable.value][2]\n", + " print(start_layer, end_layer)\n", + " out = widgets.interactive_output(display_sample_pytorch, {'seed': seed, 'truncation': truncation, 'direction': fixed(random_dir), 'distance': distance, 'scale': scale, 'start': fixed(start_layer), 'end': fixed(end_layer)})\n", + " display(select_variable)\n", + " display(ui, out)\n", + "\n", + "random_dir = latent_dirs[named_directions[select_variable.value][0]]\n", + "start_layer = named_directions[select_variable.value][1]\n", + "end_layer = named_directions[select_variable.value][2]\n", + "seed = np.random.randint(0,100000)\n", + "style = {'description_width': 'initial'}\n", + "\n", + "seed = widgets.IntSlider(min=0, max=100000, step=1, value=seed, description='Seed: ', continuous_update=False)\n", + "truncation = widgets.FloatSlider(min=0, max=2, step=0.1, value=0.7, description='Truncation: ', continuous_update=False)\n", + "distance = widgets.FloatSlider(min=-10, max=10, step=0.1, value=0, description='Distance: ', continuous_update=False, style=style)\n", + "scale = widgets.FloatSlider(min=0, max=10, step=0.05, value=1, description='Scale: ', continuous_update=False)\n", + "\n", + "bot_box = widgets.HBox([seed, truncation, distance, scale])\n", + "ui = widgets.VBox([bot_box])\n", + "out = widgets.interactive_output(display_sample_pytorch, {'seed': seed, 'truncation': truncation, 'direction': fixed(random_dir), 'distance': distance, 'scale': scale, 'start': fixed(start_layer), 'end': fixed(end_layer)})\n", + "\n", + "display(select_variable)\n", + "display(ui, out)\n", + "\n", + "select_variable.observe(set_direction, names='value')\n", + "\n" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "collapsed_sections": [], + "machine_shape": "hm", + "name": "Ganspace_colab.ipynb", + "provenance": [], + "toc_visible": true + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.9" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "06aaae9584fc4d39b8d2ab19ba2dde3e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "SliderStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "SliderStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "", + "handle_color": null + } + }, + "1e8fcebb631247578ba9aa39b6c765ff": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b47793d0bac7465497b3a61881eb3831", + "IPY_MODEL_70655d4b9050402194d000c0af617048", + "IPY_MODEL_c0fc07533df7404f9369d8935f54a8b0", + "IPY_MODEL_9dccffdade46497db2ec0f061236a3ff", + "IPY_MODEL_64fa4df388f448839feac895d645f02b", + "IPY_MODEL_8d75f788789e48009d51db574ac20b29", + "IPY_MODEL_a19fe52cddb14a9dad0f549bc0154a2a" + ], + "layout": "IPY_MODEL_7913abe6ab8b4e67828cfa5f32d244f4" + } + }, + "2f51718dae6e4c4fb70ea28e91840467": { + "model_module": "@jupyter-widgets/controls", + "model_name": "SliderStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "SliderStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "", + "handle_color": null + } + }, + "31cdd0993d464cababb6f220d8292c6e": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3dddcb7cf4d14d58b029cd8ccd1bd675": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4aae134718d24c1d93a92d962113577a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "SliderStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "SliderStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "", + "handle_color": null + } + }, + "64fa4df388f448839feac895d645f02b": { + "model_module": "@jupyter-widgets/controls", + "model_name": "IntSliderModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "IntSliderModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "IntSliderView", + "continuous_update": false, + "description": "start layer: ", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_996c259c47c644409c9b6c71b665e10c", + "max": 18, + "min": 0, + "orientation": "horizontal", + "readout": true, + "readout_format": "d", + "step": 1, + "style": "IPY_MODEL_bd3512aa9e61413eb7a6e7ba7707f0fa", + "value": 0 + } + }, + "70655d4b9050402194d000c0af617048": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatSliderModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatSliderModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "FloatSliderView", + "continuous_update": false, + "description": "Truncation: ", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_d82a4c82d6d5488a8567373b081a698c", + "max": 2, + "min": 0, + "orientation": "horizontal", + "readout": true, + "readout_format": ".2f", + "step": 0.1, + "style": "IPY_MODEL_b6b598d128f749d184548abeafad1935", + "value": 0.7 + } + }, + "7725eb04caa1491fb7da74a89f26908e": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7913abe6ab8b4e67828cfa5f32d244f4": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8a6ee9d7641f4e1a803ab688bb04d085": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8d75f788789e48009d51db574ac20b29": { + "model_module": "@jupyter-widgets/controls", + "model_name": "IntSliderModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "IntSliderModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "IntSliderView", + "continuous_update": false, + "description": "end layer: ", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_ebb903320678435386c08c4e29c4b6ad", + "max": 18, + "min": 0, + "orientation": "horizontal", + "readout": true, + "readout_format": "d", + "step": 1, + "style": "IPY_MODEL_06aaae9584fc4d39b8d2ab19ba2dde3e", + "value": 18 + } + }, + "933e21c96bb0403dbfdc737c5ddb2b0b": { + "model_module": "@jupyter-widgets/controls", + "model_name": "SliderStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "SliderStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "initial", + "handle_color": null + } + }, + "996c259c47c644409c9b6c71b665e10c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9ac961362cfd42229daab07d0ed4f8bf": { + "model_module": "@jupyter-widgets/output", + "model_name": "OutputModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/output", + "_model_module_version": "1.0.0", + "_model_name": "OutputModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/output", + "_view_module_version": "1.0.0", + "_view_name": "OutputView", + "layout": "IPY_MODEL_3dddcb7cf4d14d58b029cd8ccd1bd675", + "msg_id": "", + "outputs": [ + { + "image/png": "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\n", + "metadata": { + "tags": [] + }, + "output_type": "display_data", + "text/plain": "" + } + ] + } + }, + "9dccffdade46497db2ec0f061236a3ff": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatSliderModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatSliderModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "FloatSliderView", + "continuous_update": false, + "description": "Scale: ", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_8a6ee9d7641f4e1a803ab688bb04d085", + "max": 10, + "min": 0, + "orientation": "horizontal", + "readout": true, + "readout_format": ".2f", + "step": 0.05, + "style": "IPY_MODEL_2f51718dae6e4c4fb70ea28e91840467", + "value": 1 + } + }, + "a19fe52cddb14a9dad0f549bc0154a2a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "TextModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "TextModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "TextView", + "continuous_update": true, + "description": "Name component here", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_31cdd0993d464cababb6f220d8292c6e", + "placeholder": "​", + "style": "IPY_MODEL_ae49fe727b8b4562b034196a364ae0dc", + "value": "" + } + }, + "ae49fe727b8b4562b034196a364ae0dc": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "initial" + } + }, + "ae9f6667f56c44f193fdae884d60dcc2": { + "model_module": "@jupyter-widgets/controls", + "model_name": "VBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "VBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "VBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_1e8fcebb631247578ba9aa39b6c765ff" + ], + "layout": "IPY_MODEL_7725eb04caa1491fb7da74a89f26908e" + } + }, + "b47793d0bac7465497b3a61881eb3831": { + "model_module": "@jupyter-widgets/controls", + "model_name": "IntSliderModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "IntSliderModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "IntSliderView", + "continuous_update": false, + "description": "Seed: ", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_fb79cfa871d54ac9a6d3c089f8f22eac", + "max": 100000, + "min": 0, + "orientation": "horizontal", + "readout": true, + "readout_format": "d", + "step": 1, + "style": "IPY_MODEL_4aae134718d24c1d93a92d962113577a", + "value": 99782 + } + }, + "b6b598d128f749d184548abeafad1935": { + "model_module": "@jupyter-widgets/controls", + "model_name": "SliderStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "SliderStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "", + "handle_color": null + } + }, + "bd3512aa9e61413eb7a6e7ba7707f0fa": { + "model_module": "@jupyter-widgets/controls", + "model_name": "SliderStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "SliderStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "", + "handle_color": null + } + }, + "c0dd409781194e7f9bb8126571d4431d": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c0fc07533df7404f9369d8935f54a8b0": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatSliderModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatSliderModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "FloatSliderView", + "continuous_update": false, + "description": "Distance: ", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_c0dd409781194e7f9bb8126571d4431d", + "max": 10, + "min": -10, + "orientation": "horizontal", + "readout": true, + "readout_format": ".2f", + "step": 0.1, + "style": "IPY_MODEL_933e21c96bb0403dbfdc737c5ddb2b0b", + "value": 0 + } + }, + "d82a4c82d6d5488a8567373b081a698c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ebb903320678435386c08c4e29c4b6ad": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fb79cfa871d54ac9a6d3c089f8f22eac": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/notebooks/Ganspace_colab.ipynb b/notebooks/Ganspace_colab.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..98ba2a5d0ad9507dbef94a860cbcd538a887a436 --- /dev/null +++ b/notebooks/Ganspace_colab.ipynb @@ -0,0 +1,1664 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "yyjPqusnkHHJ", + "outputId": "8a229ada-fd1c-424c-938f-e98b0cdac9df" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TensorFlow 1.x selected.\n" + ] + } + ], + "source": [ + "%tensorflow_version 1.x" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "lM2k1EDpBZFc" + }, + "outputs": [], + "source": [ + "#@title Mount Google Drive (Optional)\n", + "from google.colab import drive\n", + "drive.mount('/content/drive/', force_remount=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "W-gc95AN_wQ4" + }, + "source": [ + "\n", + "## Setup\n", + "Hit play on all the cells below, and everything should run smoothly. The install takes around half a minute.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "both", + "id": "04xop1hZISlG" + }, + "outputs": [], + "source": [ + "# Clone git\n", + "!git clone https://github.com/harskish/ganspace\n", + "%cd ganspace\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "dKCsAiNNFLnn" + }, + "outputs": [], + "source": [ + "#@title Install remaining packages\n", + "from IPython.display import Javascript\n", + "display(Javascript('''google.colab.output.setIframeHeight(0, true, {maxHeight: 200})'''))\n", + "!pip install fbpca boto3\n", + "!git submodule update --init --recursive\n", + "!python -c \"import nltk; nltk.download('wordnet')\"\n", + "\n", + "# Custom OPs no longer required\n", + "#!pip install Ninja\n", + "#%cd models/stylegan2/stylegan2-pytorch/op\n", + "#!python setup.py install\n", + "#!python -c \"import torch; import upfirdn2d_op; import fused; print('OK')\"\n", + "#%cd \"/content/ganspace\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jo8zwRspKJBb" + }, + "source": [ + "# Convert model weights\n", + "\n", + "If you have a tensorflow model you want to use Ganspace on - convert it to a pytorch model below.\n", + "\n", + "(skip this step if you already have a pytorch model)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "0c32G3UvnFaV" + }, + "outputs": [], + "source": [ + "!gdown --id 1UlDmJVLLnBD9SnLSMXeiZRO6g-OMQCA_ -O /content/ffhq.pkl" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "tQcivtikdOsC" + }, + "outputs": [], + "source": [ + "%cd \"/content\"\n", + "!git clone https://github.com/skyflynil/stylegan2\n", + "%cd ganspace" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tQPsNKq9n2pI" + }, + "source": [ + "The convert weight script takes two arguments: \n", + "\n", + "```\n", + "--repo - Path to tensorflow stylegan2 repo\n", + " - Path to your model\n", + "```\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Pdkk4vyXtrNh" + }, + "outputs": [], + "source": [ + "!python /content/ganspace/models/stylegan2/stylegan2-pytorch/convert_weight.py --repo=\"/content/stylegan2/\" \"/content/ffhq.pkl\" #convert weights" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "-pRwkojK1uP-" + }, + "outputs": [], + "source": [ + "!cp \"/content/ganspace/ffhq.pt\" \"/content/drive/My Drive/ML/stylegan_models\" #copy pytorch model to your drive" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vhVTzEZjrdFv" + }, + "source": [ + "# Run PCA Analysis" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "MRuvtoQhrt1J" + }, + "source": [ + "From here, open models/wrappers.py, and edit the stylegan2 configs dict on line 110 to include your model and its corresponding resolution.\n", + "\n", + "I.E from\n", + "\n", + " # Image widths\n", + " configs = {\n", + " 'ffhq': 1024,\n", + " 'car': 512,\n", + " 'cat': 256,\n", + " }\n", + "\n", + "to \n", + "\n", + " # Image widths\n", + " configs = {\n", + " 'your_model': your_resolution,\n", + " 'ffhq': 1024,\n", + " 'car': 512,\n", + " 'cat': 256,\n", + " }\n", + "\n", + "Then copy your pytorch model over to your drive account or any other hosting platform, and add the direct download link to the checkpoints dict in the download_checkpoint function on line 136.\n", + "\n", + " def download_checkpoint(self, outfile):\n", + " checkpoints = {\n", + " 'yourmodel': 'https://drive.google.com/yourmodel',\n", + " 'ffhq': 'https://drive.google.com/uc?id=12yYXZymadSIj74Yue1Q7RrlbIqrXggo3',\n", + " 'car': 'https://drive.google.com/uc?export=download&id=1iRoWclWVbDBAy5iXYZrQnKYSbZUqXI6y',\n", + " 'cat': 'https://drive.google.com/uc?export=download&id=15vJP8GDr0FlRYpE8gD7CdeEz2mXrQMgN',\n", + " }\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7GggN36LpSgo" + }, + "source": [ + "##Options\n", + "\n", + "\n", + "```\n", + "Command line paramaters:\n", + " --model one of [ProGAN, BigGAN-512, BigGAN-256, BigGAN-128, StyleGAN, StyleGAN2]\n", + " --class class name; leave empty to list options\n", + " --layer layer at which to perform PCA; leave empty to list options\n", + " --use_w treat W as the main latent space (StyleGAN / StyleGAN2)\n", + " --inputs load previously exported edits from directory\n", + " --sigma number of stdevs to use in visualize.py\n", + " -n number of PCA samples\n", + " -b override automatic minibatch size detection\n", + " -c number of components to keep\n", + "\n", + "```\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "AGTY0XmaIfz_" + }, + "outputs": [], + "source": [ + "%cd ../ganspace/" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "AglcMDAUt-mm" + }, + "outputs": [], + "source": [ + "model_name = 'StyleGAN2' \n", + "model_class = 'ffhq' #this is the name of your model in the configs\n", + "num_components = 80" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "both", + "id": "7RmHtfgdomsx" + }, + "outputs": [], + "source": [ + "#Check layers available for analysis by passing dummy name\n", + "!python visualize.py --model $model_name --class $model_class --use_w --layer=dummy_name" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "iwoyJLamjciq" + }, + "source": [ + "Add chosen layer in as --layer argument:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "D41v8w25l0j8" + }, + "outputs": [], + "source": [ + "!python visualize.py --model $model_name --class $model_class --use_w --layer=style -c $num_components" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "4uSCkh4OAqOU" + }, + "outputs": [], + "source": [ + "!python visualize.py --model=$model_name --class=$model_class --use_w --layer=\"style\" -b=500 --batch --video #add -video to generate videos" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "0Vf0BDQMIVPi" + }, + "outputs": [], + "source": [ + "!python visualize.py --model=StyleGAN2 --class=ffhq --use_w --layer=style -b=10000" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "JW_I1n1DMMEO" + }, + "outputs": [], + "source": [ + "!zip -r samples.zip \"/content/ganspace/out/StyleGAN2-ffhq\" #zip up samples for download" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "k9Oz_9TjuBPc" + }, + "outputs": [], + "source": [ + "%cp -r \"/content/ganspace/cache/components\" \"/content/drive/My Drive/ML/stylegan2/comps\" #copying components over to google drive" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "m7TDzlXCHe59" + }, + "source": [ + "# Explore Directions!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Y9_fWV-NpuLA" + }, + "source": [ + "After running visualize.py, your components will be stored in an npz file in /content/ganspace/cache/components/ - below the npz file is unpacked, and a component/direction is chosen at random. \n", + "\n", + "Using the UI, you can explore the latent direction and give it a name, which will be appeneded to the named_directions dictionary and saved as 'direction_name.npy' for later use.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "rD24fpCcHnyV" + }, + "outputs": [], + "source": [ + "# Load model\n", + "from IPython.utils import io\n", + "import torch\n", + "import PIL\n", + "import numpy as np\n", + "import ipywidgets as widgets\n", + "from PIL import Image\n", + "import imageio\n", + "from models import get_instrumented_model\n", + "from decomposition import get_or_compute\n", + "from config import Config\n", + "from skimage import img_as_ubyte\n", + "\n", + "# Speed up computation\n", + "torch.autograd.set_grad_enabled(False)\n", + "torch.backends.cudnn.benchmark = True\n", + "\n", + "# Specify model to use\n", + "config = Config(\n", + " model='StyleGAN2',\n", + " layer='style',\n", + " output_class='ffhq',\n", + " components=80,\n", + " use_w=True,\n", + " batch_size=5_000, # style layer quite small\n", + ")\n", + "\n", + "inst = get_instrumented_model(config.model, config.output_class,\n", + " config.layer, torch.device('cuda'), use_w=config.use_w)\n", + "\n", + "path_to_components = get_or_compute(config, inst)\n", + "\n", + "model = inst.model\n", + "\n", + "named_directions = {} #init named_directions dict to save directions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "E8NFoXruGy_C" + }, + "outputs": [], + "source": [ + "#@title Load a component at random\n", + "\n", + "comps = np.load(path_to_components)\n", + "lst = comps.files\n", + "latent_dirs = []\n", + "latent_stdevs = []\n", + "\n", + "load_activations = False\n", + "\n", + "for item in lst:\n", + " if load_activations:\n", + " if item == 'act_comp':\n", + " for i in range(comps[item].shape[0]):\n", + " latent_dirs.append(comps[item][i])\n", + " if item == 'act_stdev':\n", + " for i in range(comps[item].shape[0]):\n", + " latent_stdevs.append(comps[item][i])\n", + " else:\n", + " if item == 'lat_comp':\n", + " for i in range(comps[item].shape[0]):\n", + " latent_dirs.append(comps[item][i])\n", + " if item == 'lat_stdev':\n", + " for i in range(comps[item].shape[0]):\n", + " latent_stdevs.append(comps[item][i])\n", + " \n", + "#load one at random \n", + "num = np.random.randint(20)\n", + "if num in named_directions.values():\n", + " print(f'Direction already named: {list(named_directions.keys())[list(named_directions.values()).index(num)]}')\n", + "\n", + "random_dir = latent_dirs[num]\n", + "random_dir_stdev = latent_stdevs[num]\n", + "\n", + "print(f'Loaded Component No. {num}')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "cellView": "form", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 549, + "referenced_widgets": [ + "ae9f6667f56c44f193fdae884d60dcc2", + "7725eb04caa1491fb7da74a89f26908e", + "1e8fcebb631247578ba9aa39b6c765ff", + "7913abe6ab8b4e67828cfa5f32d244f4", + "b47793d0bac7465497b3a61881eb3831", + "70655d4b9050402194d000c0af617048", + "c0fc07533df7404f9369d8935f54a8b0", + "9dccffdade46497db2ec0f061236a3ff", + "64fa4df388f448839feac895d645f02b", + "8d75f788789e48009d51db574ac20b29", + "a19fe52cddb14a9dad0f549bc0154a2a", + "4aae134718d24c1d93a92d962113577a", + "fb79cfa871d54ac9a6d3c089f8f22eac", + "b6b598d128f749d184548abeafad1935", + "d82a4c82d6d5488a8567373b081a698c", + "933e21c96bb0403dbfdc737c5ddb2b0b", + "c0dd409781194e7f9bb8126571d4431d", + "2f51718dae6e4c4fb70ea28e91840467", + "8a6ee9d7641f4e1a803ab688bb04d085", + "bd3512aa9e61413eb7a6e7ba7707f0fa", + "996c259c47c644409c9b6c71b665e10c", + "06aaae9584fc4d39b8d2ab19ba2dde3e", + "ebb903320678435386c08c4e29c4b6ad", + "ae49fe727b8b4562b034196a364ae0dc", + "31cdd0993d464cababb6f220d8292c6e", + "9ac961362cfd42229daab07d0ed4f8bf", + "3dddcb7cf4d14d58b029cd8ccd1bd675" + ] + }, + "id": "wJytqjrVwZ7K", + "outputId": "86e1c66d-fac3-4310-d40c-e65953062c18" + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ae9f6667f56c44f193fdae884d60dcc2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HBox(children=(IntSlider(value=99782, continuous_update=False, description='Seed: ', max=100000…" + ] + }, + "metadata": { + "tags": [] + }, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9ac961362cfd42229daab07d0ed4f8bf", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Output()" + ] + }, + "metadata": { + "tags": [] + }, + "output_type": "display_data" + } + ], + "source": [ + "#@title Run UI (save component with Enter key)\n", + "from ipywidgets import fixed\n", + "\n", + "# Taken from https://github.com/alexanderkuk/log-progress\n", + "def log_progress(sequence, every=1, size=None, name='Items'):\n", + " from ipywidgets import IntProgress, HTML, VBox\n", + " from IPython.display import display\n", + "\n", + " is_iterator = False\n", + " if size is None:\n", + " try:\n", + " size = len(sequence)\n", + " except TypeError:\n", + " is_iterator = True\n", + " if size is not None:\n", + " if every is None:\n", + " if size <= 200:\n", + " every = 1\n", + " else:\n", + " every = int(size / 200) # every 0.5%\n", + " else:\n", + " assert every is not None, 'sequence is iterator, set every'\n", + "\n", + " if is_iterator:\n", + " progress = IntProgress(min=0, max=1, value=1)\n", + " progress.bar_style = 'info'\n", + " else:\n", + " progress = IntProgress(min=0, max=size, value=0)\n", + " label = HTML()\n", + " box = VBox(children=[label, progress])\n", + " display(box)\n", + "\n", + " index = 0\n", + " try:\n", + " for index, record in enumerate(sequence, 1):\n", + " if index == 1 or index % every == 0:\n", + " if is_iterator:\n", + " label.value = '{name}: {index} / ?'.format(\n", + " name=name,\n", + " index=index\n", + " )\n", + " else:\n", + " progress.value = index\n", + " label.value = u'{name}: {index} / {size}'.format(\n", + " name=name,\n", + " index=index,\n", + " size=size\n", + " )\n", + " yield record\n", + " except:\n", + " progress.bar_style = 'danger'\n", + " raise\n", + " else:\n", + " progress.bar_style = 'success'\n", + " progress.value = index\n", + " label.value = \"{name}: {index}\".format(\n", + " name=name,\n", + " index=str(index or '?')\n", + " )\n", + "\n", + "def name_direction(sender):\n", + " if not text.value:\n", + " print('Please name the direction before saving')\n", + " return\n", + " \n", + " if num in named_directions.values():\n", + " target_key = list(named_directions.keys())[list(named_directions.values()).index(num)]\n", + " print(f'Direction already named: {target_key}')\n", + " print(f'Overwriting... ')\n", + " del(named_directions[target_key])\n", + " named_directions[text.value] = [num, start_layer.value, end_layer.value]\n", + " save_direction(random_dir, text.value)\n", + " for item in named_directions:\n", + " print(item, named_directions[item])\n", + "\n", + "def save_direction(direction, filename):\n", + " filename += \".npy\"\n", + " np.save(filename, direction, allow_pickle=True, fix_imports=True)\n", + " print(f'Latent direction saved as {filename}')\n", + "\n", + "def display_sample_pytorch(seed, truncation, direction, distance, scale, start, end, disp=True, save=None, noise_spec=None):\n", + " # blockPrint()\n", + " with io.capture_output() as captured:\n", + " w = model.sample_latent(1, seed=seed).cpu().numpy()\n", + "\n", + " model.truncation = truncation\n", + " w = [w]*model.get_max_latents() # one per layer\n", + " for l in range(start, end):\n", + " w[l] = w[l] + direction * distance * scale\n", + "\n", + " #save image and display\n", + " out = model.sample_np(w)\n", + " final_im = Image.fromarray((out * 255).astype(np.uint8)).resize((500,500),Image.LANCZOS)\n", + "\n", + " if disp:\n", + " display(final_im)\n", + " if save is not None:\n", + " if disp == False:\n", + " print(save)\n", + " final_im.save(f'out/{seed}_{save:05}.png')\n", + "\n", + "def generate_mov(seed, truncation, direction_vec, scale, layers, n_frames, out_name = 'out', noise_spec = None, loop=True):\n", + " \"\"\"Generates a mov moving back and forth along the chosen direction vector\"\"\"\n", + " # Example of reading a generated set of images, and storing as MP4.\n", + " %mkdir out\n", + " movieName = f'out/{out_name}.mp4'\n", + " offset = -10\n", + " step = 20 / n_frames\n", + " imgs = []\n", + " for i in log_progress(range(n_frames), name = \"Generating frames\"):\n", + " print(f'\\r{i} / {n_frames}', end='')\n", + " w = model.sample_latent(1, seed=seed).cpu().numpy()\n", + "\n", + " model.truncation = truncation\n", + " w = [w]*model.get_max_latents() # one per layer\n", + " for l in layers:\n", + " if l <= model.get_max_latents():\n", + " w[l] = w[l] + direction_vec * offset * scale\n", + "\n", + " #save image and display\n", + " out = model.sample_np(w)\n", + " final_im = Image.fromarray((out * 255).astype(np.uint8))\n", + " imgs.append(out)\n", + " #increase offset\n", + " offset += step\n", + " if loop:\n", + " imgs += imgs[::-1]\n", + " with imageio.get_writer(movieName, mode='I') as writer:\n", + " for image in log_progress(list(imgs), name = \"Creating animation\"):\n", + " writer.append_data(img_as_ubyte(image))\n", + "\n", + "\n", + "seed = np.random.randint(0,100000)\n", + "style = {'description_width': 'initial'}\n", + "\n", + "seed = widgets.IntSlider(min=0, max=100000, step=1, value=seed, description='Seed: ', continuous_update=False)\n", + "truncation = widgets.FloatSlider(min=0, max=2, step=0.1, value=0.7, description='Truncation: ', continuous_update=False)\n", + "distance = widgets.FloatSlider(min=-10, max=10, step=0.1, value=0, description='Distance: ', continuous_update=False, style=style)\n", + "scale = widgets.FloatSlider(min=0, max=10, step=0.05, value=1, description='Scale: ', continuous_update=False)\n", + "start_layer = widgets.IntSlider(min=0, max=model.get_max_latents(), step=1, value=0, description='start layer: ', continuous_update=False)\n", + "end_layer = widgets.IntSlider(min=0, max=model.get_max_latents(), step=1, value=18, description='end layer: ', continuous_update=False)\n", + "\n", + "# Make sure layer range is valid\n", + "def update_range_start(*args):\n", + " end_layer.min = start_layer.value\n", + "def update_range_end(*args):\n", + " start_layer.max = end_layer.value\n", + "start_layer.observe(update_range_start, 'value')\n", + "end_layer.observe(update_range_end, 'value')\n", + "\n", + "text = widgets.Text(description=\"Name component here\", style=style, width=200)\n", + "\n", + "bot_box = widgets.HBox([seed, truncation, distance, scale, start_layer, end_layer, text])\n", + "ui = widgets.VBox([bot_box])\n", + "\n", + "out = widgets.interactive_output(display_sample_pytorch, {'seed': seed, 'truncation': truncation, 'direction': fixed(random_dir), 'distance': distance, 'scale': scale, 'start': start_layer, 'end': end_layer})\n", + "\n", + "display(ui, out)\n", + "text.on_submit(name_direction)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "zJjbP91dgQui" + }, + "outputs": [], + "source": [ + "#script to generate a movie moving back and forth along the direction\n", + "\n", + "direction_name = 'raise_eyebrows'\n", + "num_samples = 5\n", + "assert direction_name in named_directions, \\\n", + " f'\"{direction_name}\" not found, please save it first using the cell above.'\n", + "\n", + "loc = named_directions[direction_name][0]\n", + "for i in range(num_samples):\n", + " s = np.random.randint(0, 10000)\n", + " generate_mov(seed = s, truncation = 0.8, direction_vec = latent_dirs[loc], scale = 2, layers=range(named_directions[direction_name][1], named_directions[direction_name][2]), n_frames = 20, out_name = f'{model_class}_{direction_name}_{i}', loop=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "dDbfx6e09dTX" + }, + "outputs": [], + "source": [ + "#@title Select from named directions\n", + "\n", + "from IPython.display import display, clear_output\n", + "\n", + "vardict = list(named_directions.keys())\n", + "select_variable = widgets.Dropdown(\n", + " options=vardict,\n", + " value=vardict[0],\n", + " description='Select variable:',\n", + " disabled=False,\n", + " button_style=''\n", + ")\n", + "\n", + "def set_direction(b):\n", + " clear_output()\n", + " random_dir = latent_dirs[named_directions[select_variable.value][0]]\n", + " start_layer = named_directions[select_variable.value][1]\n", + " end_layer = named_directions[select_variable.value][2]\n", + " print(start_layer, end_layer)\n", + " out = widgets.interactive_output(display_sample_pytorch, {'seed': seed, 'truncation': truncation, 'direction': fixed(random_dir), 'distance': distance, 'scale': scale, 'start': fixed(start_layer), 'end': fixed(end_layer)})\n", + " display(select_variable)\n", + " display(ui, out)\n", + "\n", + "random_dir = latent_dirs[named_directions[select_variable.value][0]]\n", + "start_layer = named_directions[select_variable.value][1]\n", + "end_layer = named_directions[select_variable.value][2]\n", + "seed = np.random.randint(0,100000)\n", + "style = {'description_width': 'initial'}\n", + "\n", + "seed = widgets.IntSlider(min=0, max=100000, step=1, value=seed, description='Seed: ', continuous_update=False)\n", + "truncation = widgets.FloatSlider(min=0, max=2, step=0.1, value=0.7, description='Truncation: ', continuous_update=False)\n", + "distance = widgets.FloatSlider(min=-10, max=10, step=0.1, value=0, description='Distance: ', continuous_update=False, style=style)\n", + "scale = widgets.FloatSlider(min=0, max=10, step=0.05, value=1, description='Scale: ', continuous_update=False)\n", + "\n", + "bot_box = widgets.HBox([seed, truncation, distance, scale])\n", + "ui = widgets.VBox([bot_box])\n", + "out = widgets.interactive_output(display_sample_pytorch, {'seed': seed, 'truncation': truncation, 'direction': fixed(random_dir), 'distance': distance, 'scale': scale, 'start': fixed(start_layer), 'end': fixed(end_layer)})\n", + "\n", + "display(select_variable)\n", + "display(ui, out)\n", + "\n", + "select_variable.observe(set_direction, names='value')\n", + "\n" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "collapsed_sections": [], + "machine_shape": "hm", + "name": "Ganspace_colab.ipynb", + "provenance": [], + "toc_visible": true + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.9" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "06aaae9584fc4d39b8d2ab19ba2dde3e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "SliderStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "SliderStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "", + "handle_color": null + } + }, + "1e8fcebb631247578ba9aa39b6c765ff": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b47793d0bac7465497b3a61881eb3831", + "IPY_MODEL_70655d4b9050402194d000c0af617048", + "IPY_MODEL_c0fc07533df7404f9369d8935f54a8b0", + "IPY_MODEL_9dccffdade46497db2ec0f061236a3ff", + "IPY_MODEL_64fa4df388f448839feac895d645f02b", + "IPY_MODEL_8d75f788789e48009d51db574ac20b29", + "IPY_MODEL_a19fe52cddb14a9dad0f549bc0154a2a" + ], + "layout": "IPY_MODEL_7913abe6ab8b4e67828cfa5f32d244f4" + } + }, + "2f51718dae6e4c4fb70ea28e91840467": { + "model_module": "@jupyter-widgets/controls", + "model_name": "SliderStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "SliderStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "", + "handle_color": null + } + }, + "31cdd0993d464cababb6f220d8292c6e": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3dddcb7cf4d14d58b029cd8ccd1bd675": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4aae134718d24c1d93a92d962113577a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "SliderStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "SliderStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "", + "handle_color": null + } + }, + "64fa4df388f448839feac895d645f02b": { + "model_module": "@jupyter-widgets/controls", + "model_name": "IntSliderModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "IntSliderModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "IntSliderView", + "continuous_update": false, + "description": "start layer: ", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_996c259c47c644409c9b6c71b665e10c", + "max": 18, + "min": 0, + "orientation": "horizontal", + "readout": true, + "readout_format": "d", + "step": 1, + "style": "IPY_MODEL_bd3512aa9e61413eb7a6e7ba7707f0fa", + "value": 0 + } + }, + "70655d4b9050402194d000c0af617048": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatSliderModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatSliderModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "FloatSliderView", + "continuous_update": false, + "description": "Truncation: ", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_d82a4c82d6d5488a8567373b081a698c", + "max": 2, + "min": 0, + "orientation": "horizontal", + "readout": true, + "readout_format": ".2f", + "step": 0.1, + "style": "IPY_MODEL_b6b598d128f749d184548abeafad1935", + "value": 0.7 + } + }, + "7725eb04caa1491fb7da74a89f26908e": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7913abe6ab8b4e67828cfa5f32d244f4": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8a6ee9d7641f4e1a803ab688bb04d085": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8d75f788789e48009d51db574ac20b29": { + "model_module": "@jupyter-widgets/controls", + "model_name": "IntSliderModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "IntSliderModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "IntSliderView", + "continuous_update": false, + "description": "end layer: ", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_ebb903320678435386c08c4e29c4b6ad", + "max": 18, + "min": 0, + "orientation": "horizontal", + "readout": true, + "readout_format": "d", + "step": 1, + "style": "IPY_MODEL_06aaae9584fc4d39b8d2ab19ba2dde3e", + "value": 18 + } + }, + "933e21c96bb0403dbfdc737c5ddb2b0b": { + "model_module": "@jupyter-widgets/controls", + "model_name": "SliderStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "SliderStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "initial", + "handle_color": null + } + }, + "996c259c47c644409c9b6c71b665e10c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9ac961362cfd42229daab07d0ed4f8bf": { + "model_module": "@jupyter-widgets/output", + "model_name": "OutputModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/output", + "_model_module_version": "1.0.0", + "_model_name": "OutputModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/output", + "_view_module_version": "1.0.0", + "_view_name": "OutputView", + "layout": "IPY_MODEL_3dddcb7cf4d14d58b029cd8ccd1bd675", + "msg_id": "", + "outputs": [ + { + "image/png": "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\n", + "metadata": { + "tags": [] + }, + "output_type": "display_data", + "text/plain": "" + } + ] + } + }, + "9dccffdade46497db2ec0f061236a3ff": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatSliderModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatSliderModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "FloatSliderView", + "continuous_update": false, + "description": "Scale: ", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_8a6ee9d7641f4e1a803ab688bb04d085", + "max": 10, + "min": 0, + "orientation": "horizontal", + "readout": true, + "readout_format": ".2f", + "step": 0.05, + "style": "IPY_MODEL_2f51718dae6e4c4fb70ea28e91840467", + "value": 1 + } + }, + "a19fe52cddb14a9dad0f549bc0154a2a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "TextModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "TextModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "TextView", + "continuous_update": true, + "description": "Name component here", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_31cdd0993d464cababb6f220d8292c6e", + "placeholder": "​", + "style": "IPY_MODEL_ae49fe727b8b4562b034196a364ae0dc", + "value": "" + } + }, + "ae49fe727b8b4562b034196a364ae0dc": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "initial" + } + }, + "ae9f6667f56c44f193fdae884d60dcc2": { + "model_module": "@jupyter-widgets/controls", + "model_name": "VBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "VBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "VBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_1e8fcebb631247578ba9aa39b6c765ff" + ], + "layout": "IPY_MODEL_7725eb04caa1491fb7da74a89f26908e" + } + }, + "b47793d0bac7465497b3a61881eb3831": { + "model_module": "@jupyter-widgets/controls", + "model_name": "IntSliderModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "IntSliderModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "IntSliderView", + "continuous_update": false, + "description": "Seed: ", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_fb79cfa871d54ac9a6d3c089f8f22eac", + "max": 100000, + "min": 0, + "orientation": "horizontal", + "readout": true, + "readout_format": "d", + "step": 1, + "style": "IPY_MODEL_4aae134718d24c1d93a92d962113577a", + "value": 99782 + } + }, + "b6b598d128f749d184548abeafad1935": { + "model_module": "@jupyter-widgets/controls", + "model_name": "SliderStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "SliderStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "", + "handle_color": null + } + }, + "bd3512aa9e61413eb7a6e7ba7707f0fa": { + "model_module": "@jupyter-widgets/controls", + "model_name": "SliderStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "SliderStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "", + "handle_color": null + } + }, + "c0dd409781194e7f9bb8126571d4431d": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c0fc07533df7404f9369d8935f54a8b0": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatSliderModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatSliderModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "FloatSliderView", + "continuous_update": false, + "description": "Distance: ", + "description_tooltip": null, + "disabled": false, + "layout": "IPY_MODEL_c0dd409781194e7f9bb8126571d4431d", + "max": 10, + "min": -10, + "orientation": "horizontal", + "readout": true, + "readout_format": ".2f", + "step": 0.1, + "style": "IPY_MODEL_933e21c96bb0403dbfdc737c5ddb2b0b", + "value": 0 + } + }, + "d82a4c82d6d5488a8567373b081a698c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ebb903320678435386c08c4e29c4b6ad": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fb79cfa871d54ac9a6d3c089f8f22eac": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/notebooks/data/interfacegan/pggan_celebahq_age_boundary.npy b/notebooks/data/interfacegan/pggan_celebahq_age_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..20b0bb33c140977574f31f95cc11dac5abb285b2 --- /dev/null +++ b/notebooks/data/interfacegan/pggan_celebahq_age_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:21f0c9e8d770d5dbcf8a595a0a3393ef06493f1ea10a7e94bdd9d377b4b25808 +size 4224 diff --git a/notebooks/data/interfacegan/pggan_celebahq_age_c_eyeglasses_boundary.npy b/notebooks/data/interfacegan/pggan_celebahq_age_c_eyeglasses_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..e9cb29a11de23d2410a75b87cbc378b8cbfb38b3 --- /dev/null +++ b/notebooks/data/interfacegan/pggan_celebahq_age_c_eyeglasses_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b302977794404669617e94801a8b42cd202279b871f8afb8f9cd0565bbbd476d +size 4224 diff --git a/notebooks/data/interfacegan/pggan_celebahq_age_c_gender_boundary.npy b/notebooks/data/interfacegan/pggan_celebahq_age_c_gender_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..30d167987b77cae859ae09f31f3ab9dfb9f48cfa --- /dev/null +++ b/notebooks/data/interfacegan/pggan_celebahq_age_c_gender_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:99deeeef7c80dad287767f95cc228b2d225b3985e63f5ac42f4d38b182c47995 +size 4224 diff --git a/notebooks/data/interfacegan/pggan_celebahq_age_c_gender_eyeglasses_boundary.npy b/notebooks/data/interfacegan/pggan_celebahq_age_c_gender_eyeglasses_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..a42bd9b0aea536ae2e5b758bb41ad8a7fbb27365 --- /dev/null +++ b/notebooks/data/interfacegan/pggan_celebahq_age_c_gender_eyeglasses_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b9d3c3c30f22f45c9a2be50c187c1ffc26e22cc9c6a5cbc25bf6d79661029aa4 +size 4224 diff --git a/notebooks/data/interfacegan/pggan_celebahq_eyeglasses_boundary.npy b/notebooks/data/interfacegan/pggan_celebahq_eyeglasses_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..fdc9b301045f5b6baebd45910ecd1359e50d471c --- /dev/null +++ b/notebooks/data/interfacegan/pggan_celebahq_eyeglasses_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:610887e564b02f3bdb40ceeb74ecf35d996f10fa4726b813ce3222a7ec0d0cb2 +size 4224 diff --git a/notebooks/data/interfacegan/pggan_celebahq_eyeglasses_c_age_boundary.npy b/notebooks/data/interfacegan/pggan_celebahq_eyeglasses_c_age_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..212adada63c687589105e8eba79ca4f199acc326 --- /dev/null +++ b/notebooks/data/interfacegan/pggan_celebahq_eyeglasses_c_age_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:be3ded3af1aa222a9f2629b88bbf63ca61b7e2f632200b814bed42f372762afa +size 4224 diff --git a/notebooks/data/interfacegan/pggan_celebahq_eyeglasses_c_age_gender_boundary.npy b/notebooks/data/interfacegan/pggan_celebahq_eyeglasses_c_age_gender_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..1b947265d74b8663c16f55e841450ad36d09f7e6 --- /dev/null +++ b/notebooks/data/interfacegan/pggan_celebahq_eyeglasses_c_age_gender_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:22285e42c3d21dcfbcb228e0c13fb7113ffe58caf43e4238a0805d1cce66250d +size 4224 diff --git a/notebooks/data/interfacegan/pggan_celebahq_eyeglasses_c_gender_boundary.npy b/notebooks/data/interfacegan/pggan_celebahq_eyeglasses_c_gender_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..6586f6188fd2684dab282f9f7b5b28a3fb45ff29 --- /dev/null +++ b/notebooks/data/interfacegan/pggan_celebahq_eyeglasses_c_gender_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:36a3d5cc5be0318a7093e6a917aac7a7111fa6c8db45b44f0a4b58265f9e04ff +size 4224 diff --git a/notebooks/data/interfacegan/pggan_celebahq_gender_boundary.npy b/notebooks/data/interfacegan/pggan_celebahq_gender_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..3f646017c64673fede04a0df520d071b8acc8a34 --- /dev/null +++ b/notebooks/data/interfacegan/pggan_celebahq_gender_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:52d8d086930c2b75a0ecfd526fcb373781398d78ec76dd89216074d7769833f1 +size 4224 diff --git a/notebooks/data/interfacegan/pggan_celebahq_gender_c_age_boundary.npy b/notebooks/data/interfacegan/pggan_celebahq_gender_c_age_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..c55d86b7f49c38538faca192be22f80ee228c075 --- /dev/null +++ b/notebooks/data/interfacegan/pggan_celebahq_gender_c_age_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bfd76a86f0db88fb640525db9f4c60894cff506d9627175fb6bf300666de040f +size 4224 diff --git a/notebooks/data/interfacegan/pggan_celebahq_gender_c_age_eyeglasses_boundary.npy b/notebooks/data/interfacegan/pggan_celebahq_gender_c_age_eyeglasses_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..c1b3a48cace58e1315cc5deb2a4387d38c854c2a --- /dev/null +++ b/notebooks/data/interfacegan/pggan_celebahq_gender_c_age_eyeglasses_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:83acb608b370390615fc0dd9dc325cbc49f1ada1f0e8f8252d3e043cfbc13cb7 +size 4224 diff --git a/notebooks/data/interfacegan/pggan_celebahq_gender_c_eyeglasses_boundary.npy b/notebooks/data/interfacegan/pggan_celebahq_gender_c_eyeglasses_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..31bb10d9519fe08c1a42983683c8f9605fc69629 --- /dev/null +++ b/notebooks/data/interfacegan/pggan_celebahq_gender_c_eyeglasses_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ada9cf353ac6195c350a311557bfe20187d467c636007a910539811d49cfd701 +size 4224 diff --git a/notebooks/data/interfacegan/pggan_celebahq_pose_boundary.npy b/notebooks/data/interfacegan/pggan_celebahq_pose_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..80af910ee3a45bb48f81a358367446769ff7e432 --- /dev/null +++ b/notebooks/data/interfacegan/pggan_celebahq_pose_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4f2ad3c43ecc4dcd58362e7a8e340c39992c9c8a66bfae5ca381f050f9a519a8 +size 4224 diff --git a/notebooks/data/interfacegan/pggan_celebahq_quality_boundary.npy b/notebooks/data/interfacegan/pggan_celebahq_quality_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..f9e6f649fe296cdcd394879fb3eb9f7242192dfe --- /dev/null +++ b/notebooks/data/interfacegan/pggan_celebahq_quality_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2d7299e94d20e6e29025c9a2a633441054988f4674cfa2dad80b794bad26333d +size 4224 diff --git a/notebooks/data/interfacegan/pggan_celebahq_smile_boundary.npy b/notebooks/data/interfacegan/pggan_celebahq_smile_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..e6098497bd97653d4b8880042ac6207ae03fcad1 --- /dev/null +++ b/notebooks/data/interfacegan/pggan_celebahq_smile_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a8005cd24aa46d2810065358480cae4611bf8b8838ac453ec148a58a0162c3a8 +size 4224 diff --git a/notebooks/data/interfacegan/stylegan_celebahq_age_boundary.npy b/notebooks/data/interfacegan/stylegan_celebahq_age_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..070c510e8b20520b12385ab3afd16d0029b1ad0d --- /dev/null +++ b/notebooks/data/interfacegan/stylegan_celebahq_age_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ff4095c4cbc389e88a30b5faf351e641b598f6af50960b45d29f36ad2b278127 +size 4224 diff --git a/notebooks/data/interfacegan/stylegan_celebahq_age_w_boundary.npy b/notebooks/data/interfacegan/stylegan_celebahq_age_w_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..09d06959d9bcea20e721087029631bd57a765498 --- /dev/null +++ b/notebooks/data/interfacegan/stylegan_celebahq_age_w_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1193f356feb29bb535c689d2c14d2f6971318117eba2c3601df2a97c6339eb95 +size 4224 diff --git a/notebooks/data/interfacegan/stylegan_celebahq_eyeglasses_boundary.npy b/notebooks/data/interfacegan/stylegan_celebahq_eyeglasses_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..6d790c396202f95d3d1665f9d1c0cc79a05c9397 --- /dev/null +++ b/notebooks/data/interfacegan/stylegan_celebahq_eyeglasses_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:01d8de63932d2d5328c9aaca4af59ad0a8d5ab87dc95e55cc607ffe20f1184ed +size 4224 diff --git a/notebooks/data/interfacegan/stylegan_celebahq_eyeglasses_w_boundary.npy b/notebooks/data/interfacegan/stylegan_celebahq_eyeglasses_w_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..c58d4919c064d836b52017bb05cf8100c92b2a8b --- /dev/null +++ b/notebooks/data/interfacegan/stylegan_celebahq_eyeglasses_w_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:897301c31db00bab38f709252ed7acff4c3b827abac1e0deed0c8ea590c6ebf9 +size 4224 diff --git a/notebooks/data/interfacegan/stylegan_celebahq_gender_boundary.npy b/notebooks/data/interfacegan/stylegan_celebahq_gender_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..2696e74fd75ef336d40f22d6684c3df0bdfb08bb --- /dev/null +++ b/notebooks/data/interfacegan/stylegan_celebahq_gender_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0d466f14cd644f7444c02614bdb0cef18ca9e8172f2794c156266ef2deb66141 +size 4224 diff --git a/notebooks/data/interfacegan/stylegan_celebahq_gender_w_boundary.npy b/notebooks/data/interfacegan/stylegan_celebahq_gender_w_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..6cd700b06045dd6593f8cfb32fe1d4a04b48e35a --- /dev/null +++ b/notebooks/data/interfacegan/stylegan_celebahq_gender_w_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:efa7d73ce4186bd791aa61a8deb2a2b7fae975381b80f3d48fa4361b80d00300 +size 4224 diff --git a/notebooks/data/interfacegan/stylegan_celebahq_pose_boundary.npy b/notebooks/data/interfacegan/stylegan_celebahq_pose_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..8765992e0ac81ce1a6f652fc89f168ad18232f1b --- /dev/null +++ b/notebooks/data/interfacegan/stylegan_celebahq_pose_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2d06a03300ea1ccfceda408333d751193db604c6cc939dc4e8aee1eb46dd7851 +size 4224 diff --git a/notebooks/data/interfacegan/stylegan_celebahq_pose_w_boundary.npy b/notebooks/data/interfacegan/stylegan_celebahq_pose_w_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..7f9036903b7fbe79ddde508c3145d479bfb5417e --- /dev/null +++ b/notebooks/data/interfacegan/stylegan_celebahq_pose_w_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3da694dc6d08be345c58cc259be5af925bcf6fd43a69df370b1235b36fc79274 +size 4224 diff --git a/notebooks/data/interfacegan/stylegan_celebahq_smile_boundary.npy b/notebooks/data/interfacegan/stylegan_celebahq_smile_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..55f6e6f255433376c45b5851b9c77b699ee7ae75 --- /dev/null +++ b/notebooks/data/interfacegan/stylegan_celebahq_smile_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fe58f46c58a42b833c1cb1d12f3a1089f51a53746dda1f691ae19f05c1d36879 +size 4224 diff --git a/notebooks/data/interfacegan/stylegan_celebahq_smile_w_boundary.npy b/notebooks/data/interfacegan/stylegan_celebahq_smile_w_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..34f1bb4b92c7c215936d31d06a222ed594163127 --- /dev/null +++ b/notebooks/data/interfacegan/stylegan_celebahq_smile_w_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a722af195a3b6372027edbbd1aed3880bbb882fae45cfc4cb24a21a6ef37c82e +size 4224 diff --git a/notebooks/data/interfacegan/stylegan_ffhq_age_boundary.npy b/notebooks/data/interfacegan/stylegan_ffhq_age_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..d14267316158bb19a9a44482a6f11ef4d761ed9e --- /dev/null +++ b/notebooks/data/interfacegan/stylegan_ffhq_age_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4317407b6601233af2ccdd912f30622636309a05c799c36cc5ce25271bb66488 +size 4224 diff --git a/notebooks/data/interfacegan/stylegan_ffhq_age_c_eyeglasses_boundary.npy b/notebooks/data/interfacegan/stylegan_ffhq_age_c_eyeglasses_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..1c0491e9f89be476d5f65fdd2b0af77ac1c7ca5b --- /dev/null +++ b/notebooks/data/interfacegan/stylegan_ffhq_age_c_eyeglasses_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7ecaf2f7e5bde4749792990b1d1be95636e99ce5ffe61ef2df4d9f79b7ae671b +size 4224 diff --git a/notebooks/data/interfacegan/stylegan_ffhq_age_c_gender_boundary.npy b/notebooks/data/interfacegan/stylegan_ffhq_age_c_gender_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..3bd980b7ce9da6ca65b0f10ef5eeb86b7a761d06 --- /dev/null +++ b/notebooks/data/interfacegan/stylegan_ffhq_age_c_gender_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e9defc75fddaca12b7c0cef4fe87dfb9c9778e2ab1921b466657e241388a5e62 +size 4224 diff --git a/notebooks/data/interfacegan/stylegan_ffhq_age_w_boundary.npy b/notebooks/data/interfacegan/stylegan_ffhq_age_w_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..6c9562c219f8ed8c4997105cdabb12386bf50ba6 --- /dev/null +++ b/notebooks/data/interfacegan/stylegan_ffhq_age_w_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f92c72c6621fd9630a2100168462a15a531bee410099847fdcdf844159eb7e30 +size 4224 diff --git a/notebooks/data/interfacegan/stylegan_ffhq_eyeglasses_boundary.npy b/notebooks/data/interfacegan/stylegan_ffhq_eyeglasses_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..cc8c7278414aa3648cf03cac2ec7a6a49ae34078 --- /dev/null +++ b/notebooks/data/interfacegan/stylegan_ffhq_eyeglasses_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:449efdec8d5890db3697f083a1c8525e84a03b6ca04ac0da8c14ad1be2985d83 +size 4224 diff --git a/notebooks/data/interfacegan/stylegan_ffhq_eyeglasses_c_age_boundary.npy b/notebooks/data/interfacegan/stylegan_ffhq_eyeglasses_c_age_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..c1d3082f272670e2e5dfb840a40e1f6f3faa5046 --- /dev/null +++ b/notebooks/data/interfacegan/stylegan_ffhq_eyeglasses_c_age_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5f0d6dc4a2c37a4345c9278189bb4652f1af5d06323575d100cda8e1a978383f +size 4224 diff --git a/notebooks/data/interfacegan/stylegan_ffhq_eyeglasses_c_gender_boundary.npy b/notebooks/data/interfacegan/stylegan_ffhq_eyeglasses_c_gender_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..325d371b3a0f3b7afe1517231520f9cf5e949a4a --- /dev/null +++ b/notebooks/data/interfacegan/stylegan_ffhq_eyeglasses_c_gender_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9705c101d9156c7c35c897828b654495b0b1893760e78ca97daf7c9b2ed415ab +size 4224 diff --git a/notebooks/data/interfacegan/stylegan_ffhq_eyeglasses_w_boundary.npy b/notebooks/data/interfacegan/stylegan_ffhq_eyeglasses_w_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..5662d3a9028083e0a9743eb767dd7450c3f4bc59 --- /dev/null +++ b/notebooks/data/interfacegan/stylegan_ffhq_eyeglasses_w_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ac826235cc7347eb1f57ba9e6e2904e52f34a6052a4db03dc693648a4f231cc5 +size 4224 diff --git a/notebooks/data/interfacegan/stylegan_ffhq_gender_boundary.npy b/notebooks/data/interfacegan/stylegan_ffhq_gender_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..714c7d151f75533d7e62f6ba9ed0a74faf1e91cf --- /dev/null +++ b/notebooks/data/interfacegan/stylegan_ffhq_gender_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4fd66591b88ab174605db9e8e7fb2c2cdcd366d0bf4d068cbee0843e04c02100 +size 4224 diff --git a/notebooks/data/interfacegan/stylegan_ffhq_gender_w_boundary.npy b/notebooks/data/interfacegan/stylegan_ffhq_gender_w_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..80d10668137335f80ee384c7dda93b6c2414da0b --- /dev/null +++ b/notebooks/data/interfacegan/stylegan_ffhq_gender_w_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:077953b129bbb52605b3391d4824938c9ded35337f60d282478c72dcc3c5c28f +size 4224 diff --git a/notebooks/data/interfacegan/stylegan_ffhq_pose_boundary.npy b/notebooks/data/interfacegan/stylegan_ffhq_pose_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..2b4fb476fdde281111e17df4d73b17e7a26f91c3 --- /dev/null +++ b/notebooks/data/interfacegan/stylegan_ffhq_pose_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5f86d2db1961c9636b3c172a822a038641060d7a7d55a3912a6881e46996df78 +size 4224 diff --git a/notebooks/data/interfacegan/stylegan_ffhq_pose_w_boundary.npy b/notebooks/data/interfacegan/stylegan_ffhq_pose_w_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..9fe92dc3785a0be870e5c6ec50d5be718b6d4695 --- /dev/null +++ b/notebooks/data/interfacegan/stylegan_ffhq_pose_w_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:688585cf4d2bc3eead7bc18b4cf6e0985a0beb8a5ed46f25a08b2925d33efc1a +size 4224 diff --git a/notebooks/data/interfacegan/stylegan_ffhq_smile_boundary.npy b/notebooks/data/interfacegan/stylegan_ffhq_smile_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..f42caa7164e9018efc8a42092be7b5b0993abbbc --- /dev/null +++ b/notebooks/data/interfacegan/stylegan_ffhq_smile_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ea42deb1077732d9689d0b41bee689e6d3605eb863638ac3011935738b020ca6 +size 4224 diff --git a/notebooks/data/interfacegan/stylegan_ffhq_smile_w_boundary.npy b/notebooks/data/interfacegan/stylegan_ffhq_smile_w_boundary.npy new file mode 100644 index 0000000000000000000000000000000000000000..b8af720b08035ea061727920dcf8e573fe0b033d --- /dev/null +++ b/notebooks/data/interfacegan/stylegan_ffhq_smile_w_boundary.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5a729c200c2c933806116cb77624ccedbd6fce21aa98fca8be49aeaa35caa1c7 +size 4224 diff --git a/notebooks/data/steerability/biggan_deep_512/gan_steer-linear_shiftx_512.pkl b/notebooks/data/steerability/biggan_deep_512/gan_steer-linear_shiftx_512.pkl new file mode 100644 index 0000000000000000000000000000000000000000..0ec392535d1b7d74d05567b288b201aaa06cad48 --- /dev/null +++ b/notebooks/data/steerability/biggan_deep_512/gan_steer-linear_shiftx_512.pkl @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3b759f939533ea25cb93133bc3d1b94da53cf12530c14ed2b36455d423d00234 +size 693 diff --git a/notebooks/data/steerability/biggan_deep_512/gan_steer-linear_zoom_512.pkl b/notebooks/data/steerability/biggan_deep_512/gan_steer-linear_zoom_512.pkl new file mode 100644 index 0000000000000000000000000000000000000000..018ba1e5e27a8ef10802f3291a805ccfca07759d --- /dev/null +++ b/notebooks/data/steerability/biggan_deep_512/gan_steer-linear_zoom_512.pkl @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8126a17d6afda72a0499de5548ce63992ae382668f100cef533d277da1b2c272 +size 691 diff --git a/notebooks/data/steerability/stylegan_cars/rotate2d.npy b/notebooks/data/steerability/stylegan_cars/rotate2d.npy new file mode 100644 index 0000000000000000000000000000000000000000..2a6f2b7a0f2e800b76526ab44e077e3081f47cdf --- /dev/null +++ b/notebooks/data/steerability/stylegan_cars/rotate2d.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1ac46dbcc3df6dad344937204969efee2646a83a9bbc7687a67a720c820a6d44 +size 32896 diff --git a/notebooks/data/steerability/stylegan_cars/shifty.npy b/notebooks/data/steerability/stylegan_cars/shifty.npy new file mode 100644 index 0000000000000000000000000000000000000000..1ef57c05d03ed44101874535c57e91f769342134 --- /dev/null +++ b/notebooks/data/steerability/stylegan_cars/shifty.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3af303728ba0af34966f95af5c952d7aa0eb5a5f2123fe2f960f6312a27e0f98 +size 32896 diff --git a/notebooks/data/steerability/stylegan_ffhq/ffhq_rgb_0.npy b/notebooks/data/steerability/stylegan_ffhq/ffhq_rgb_0.npy new file mode 100644 index 0000000000000000000000000000000000000000..577c1107c67eee7c03fd52159420e42683a4d702 --- /dev/null +++ b/notebooks/data/steerability/stylegan_ffhq/ffhq_rgb_0.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c219e6b306fed0fa932f324a74512ed3b9a947195794d8a14079e2fc9f711177 +size 36992 diff --git a/notebooks/data/steerability/stylegan_ffhq/ffhq_rgb_1.npy b/notebooks/data/steerability/stylegan_ffhq/ffhq_rgb_1.npy new file mode 100644 index 0000000000000000000000000000000000000000..fa199df5660194f4c7530f631163fd99a2740fdf --- /dev/null +++ b/notebooks/data/steerability/stylegan_ffhq/ffhq_rgb_1.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:52211118c77a4b7f81d3925874cf54f63c479558175d8c55b18f82bce3dc94cd +size 36992 diff --git a/notebooks/data/steerability/stylegan_ffhq/ffhq_rgb_2.npy b/notebooks/data/steerability/stylegan_ffhq/ffhq_rgb_2.npy new file mode 100644 index 0000000000000000000000000000000000000000..0c4ed971b7552a454fba842da7d438a9733a485e --- /dev/null +++ b/notebooks/data/steerability/stylegan_ffhq/ffhq_rgb_2.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f83c80fadf4a035dcc222e7e65268208b257942e879f30a4858e41d55114c0a7 +size 36992 diff --git a/notebooks/figure_biggan_edit_transferability.ipynb b/notebooks/figure_biggan_edit_transferability.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..8d09d967a657f906a95b559b0b630ed94059b6fc --- /dev/null +++ b/notebooks/figure_biggan_edit_transferability.ipynb @@ -0,0 +1,177 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Copyright 2020 Erik Härkönen. All rights reserved.\n", + "# This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n", + "# you may not use this file except in compliance with the License. You may obtain a copy\n", + "# of the License at http://www.apache.org/licenses/LICENSE-2.0\n", + "\n", + "# Unless required by applicable law or agreed to in writing, software distributed under\n", + "# the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n", + "# OF ANY KIND, either express or implied. See the License for the specific language\n", + "# governing permissions and limitations under the License.\n", + "\n", + "# Figure: BigGAN edit transferability between classes\n", + "%matplotlib inline\n", + "from notebook_init import *\n", + "\n", + "rand = lambda : np.random.randint(np.iinfo(np.int32).max)\n", + "outdir = Path('out/figures/edit_transferability')\n", + "makedirs(outdir, exist_ok=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "inst = get_instrumented_model('BigGAN-512', 'husky', 'generator.gen_z', device, inst=inst)\n", + "model = inst.model\n", + "model.truncation = 0.7\n", + "\n", + "pc_config = Config(components=80, n=1_000_000,\n", + " layer='generator.gen_z', model='BigGAN-512', output_class='husky')\n", + "dump_name = get_or_compute(pc_config, inst)\n", + "\n", + "with np.load(dump_name) as data:\n", + " lat_comp = data['lat_comp']\n", + " lat_mean = data['lat_mean']\n", + " lat_std = data['lat_stdev']\n", + "\n", + "# name: component_idx, layer_start, layer_end, strength\n", + "edits = {\n", + " 'translate_x': ( 0, 0, 15, -3.0),\n", + " 'zoom': ( 6, 0, 15, 2.0),\n", + " 'clouds': (54, 7, 10, 15.0),\n", + " #'dark_fg': (51, 7, 10, 20.0),\n", + " 'sunlight': (33, 7, 10, 25.0),\n", + " #'silouette': (13, 7, 10, -20.0),\n", + " #'grass_bg': (69, 3, 7, -20.0),\n", + "}\n", + "\n", + "def apply_offset(z, idx, start, end, sigma):\n", + " lat = z if isinstance(z, list) else [z]*model.get_max_latents()\n", + " for i in range(start, end):\n", + " lat[i] = lat[i] + lat_comp[idx]*lat_std[idx]*sigma\n", + " return lat\n", + "\n", + "show = True\n", + "\n", + "# good geom seeds: 2145371585\n", + "# good style seeds: 337336281, 2075156369, 311784160\n", + "\n", + "for _ in range(1):\n", + " \n", + " # Type 1: geometric edit - transfers well\n", + " \n", + " seed1_geom = 2145371585\n", + " seed2_geom = 2046317118\n", + " print('Seeds geom:', [seed1_geom, seed2_geom])\n", + " z1 = model.sample_latent(1, seed=seed1_geom).cpu().numpy()\n", + " z2 = model.sample_latent(1, seed=seed2_geom).cpu().numpy()\n", + "\n", + " model.set_output_class('husky')\n", + " base_husky = model.sample_np(z1)\n", + " zoom_husky = model.sample_np(apply_offset(z1, *edits['zoom']))\n", + " transl_husky = model.sample_np(apply_offset(z1, *edits['translate_x']))\n", + " img_geom1 = np.hstack([base_husky, zoom_husky, transl_husky])\n", + "\n", + " model.set_output_class('castle')\n", + " base_castle = model.sample_np(z2)\n", + " zoom_castle = model.sample_np(apply_offset(z2, *edits['zoom']))\n", + " transl_castle = model.sample_np(apply_offset(z2, *edits['translate_x']))\n", + " img_geom2 = np.hstack([base_castle, zoom_castle, transl_castle])\n", + "\n", + " \n", + " # Type 2: style edit - often transfers\n", + " \n", + " seed1_style = 417482011 #rand()\n", + " seed2_style = 1026291813\n", + " print('Seeds style:', [seed1_style, seed2_style])\n", + " z1 = model.sample_latent(1, seed=seed1_style).cpu().numpy()\n", + " z2 = model.sample_latent(1, seed=seed2_style).cpu().numpy()\n", + "\n", + " model.set_output_class('lighthouse')\n", + " base_lighthouse = model.sample_np(z2)\n", + " edit1_lighthouse = model.sample_np(apply_offset(z2, *edits['clouds']))\n", + " edit2_lighthouse = model.sample_np(apply_offset(z2, *edits['sunlight']))\n", + " img_style2 = np.hstack([base_lighthouse, edit1_lighthouse, edit2_lighthouse])\n", + " \n", + " model.set_output_class('barn')\n", + " base_barn = model.sample_np(z1)\n", + " edit1_barn = model.sample_np(apply_offset(z1, *edits['clouds']))\n", + " edit2_barn = model.sample_np(apply_offset(z1, *edits['sunlight']))\n", + " img_style1 = np.hstack([base_barn, edit1_barn, edit2_barn])\n", + " \n", + " \n", + " grid = np.vstack([img_geom1, img_geom2, img_style1, img_style2])\n", + " \n", + " if show:\n", + " plt.figure(figsize=(12,12))\n", + " plt.imshow(grid)\n", + " plt.axis('off')\n", + " plt.show()\n", + " else:\n", + " Image.fromarray((255*grid).astype(np.uint8)).save(outdir / f'{seed1_geom}_{seed2_geom}_{seed1_style}_{seed2_style}_transf.jpg')\n", + " \n", + " # Save individual frames\n", + " Image.fromarray((255*base_husky).astype(np.uint8)).save(outdir / 'geom_husky_1.png')\n", + " Image.fromarray((255*zoom_husky).astype(np.uint8)).save(outdir / 'geom_husky_2.png')\n", + " Image.fromarray((255*transl_husky).astype(np.uint8)).save(outdir / 'geom_husky_3.png')\n", + " Image.fromarray((255*base_castle).astype(np.uint8)).save(outdir / 'geom_castle_1.png')\n", + " Image.fromarray((255*zoom_castle).astype(np.uint8)).save(outdir / 'geom_castle_2.png')\n", + " Image.fromarray((255*transl_castle).astype(np.uint8)).save(outdir / 'geom_castle_3.png')\n", + " \n", + " Image.fromarray((255*base_lighthouse).astype(np.uint8)).save(outdir / 'style_lighthouse_1.png')\n", + " Image.fromarray((255*edit1_lighthouse).astype(np.uint8)).save(outdir / 'style_lighthouse_2.png')\n", + " Image.fromarray((255*edit2_lighthouse).astype(np.uint8)).save(outdir / 'style_lighthouse_3.png')\n", + " Image.fromarray((255*base_barn).astype(np.uint8)).save(outdir / 'style_barn_1.png')\n", + " Image.fromarray((255*edit1_barn).astype(np.uint8)).save(outdir / 'style_barn_2.png')\n", + " Image.fromarray((255*edit2_barn).astype(np.uint8)).save(outdir / 'style_barn_3.png')\n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "file_extension": ".py", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.5" + }, + "mimetype": "text/x-python", + "name": "python", + "npconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": 3 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/figure_biggan_style_mixing.ipynb b/notebooks/figure_biggan_style_mixing.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..75d1f9d68ca63e6def6d1e638bcae6c77fc546bb --- /dev/null +++ b/notebooks/figure_biggan_style_mixing.ipynb @@ -0,0 +1,220 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Copyright 2020 Erik Härkönen. All rights reserved.\n", + "# This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n", + "# you may not use this file except in compliance with the License. You may obtain a copy\n", + "# of the License at http://www.apache.org/licenses/LICENSE-2.0\n", + "\n", + "# Unless required by applicable law or agreed to in writing, software distributed under\n", + "# the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n", + "# OF ANY KIND, either express or implied. See the License for the specific language\n", + "# governing permissions and limitations under the License.\n", + "\n", + "# Recreate StyleGAN1 style mixing image grid\n", + "from IPython.display import Image as IPyImage\n", + "from IPython.core.display import HTML \n", + "#IPyImage('style_mixing.png')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "from notebook_init import *\n", + "\n", + "layer_names = [f'generator.layers.{i}' for i in range(14)] # annotate all shapes\n", + "inst = get_instrumented_model('BigGAN-512', 'promontory', layer_names, device)\n", + "model = inst.model\n", + "inst.close()\n", + "\n", + "torch.manual_seed(0)\n", + "np.random.seed(0)\n", + "\n", + "makedirs('out', exist_ok=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def generate(trunc, cls, custom_seeds=[], layers=[0, 2, 4], N=5):\n", + " inst.remove_edits()\n", + " model.set_output_class(cls)\n", + " \n", + " custom_seeds = custom_seeds[:N] # limit to N images\n", + " seeds = np.random.randint(np.iinfo(np.int32).max, size=N)\n", + " seeds[:len(custom_seeds)] = custom_seeds\n", + " print(seeds, trunc, cls)\n", + " \n", + " latents = [model.sample_latent(1, truncation=trunc, seed=s) for s in seeds]\n", + " latent_a = latents[0]\n", + " out_a = model.sample_np(latent_a)\n", + "\n", + " outputs = [model.sample_np(z) for z in latents]\n", + " empty = np.ones_like(outputs[0])\n", + "\n", + " # Inputs B\n", + " row0 = np.hstack([empty] + outputs[1:])\n", + " rows = [row0]\n", + "\n", + " # Mix style starting from layer l\n", + " for layer_num in layers:\n", + " inst.close()\n", + " layer_name = f'generator.layers.{layer_num}'\n", + " inst.retain_layer(layer_name)\n", + "\n", + " imgs = []\n", + "\n", + " imgs.append(out_a)\n", + " model.partial_forward(latent_a, layer_name)\n", + " feat_a = inst.retained_features()[layer_name].detach()\n", + "\n", + " # Generate hybrids\n", + " for i in range(1, len(latents)):\n", + " # Use latent of B, early activations of A\n", + " inst.edit_layer(layer_name, ablation=1.0, replacement=feat_a)\n", + " out_b = model.sample_np(latents[i])\n", + " imgs.append(out_b)\n", + "\n", + " rows.append(np.hstack(imgs))\n", + "\n", + " grid = np.vstack(rows)\n", + " im = Image.fromarray((grid*255).astype(np.uint8))\n", + " im.save(f'out/grid_{cls}.png')\n", + "\n", + " plt.figure(figsize=(15,15))\n", + " plt.imshow(grid)\n", + " plt.axis('off')\n", + " plt.show()\n", + "\n", + " from IPython.display import Javascript, display\n", + " \n", + " if 0:\n", + " display(Javascript(\"\"\"\n", + " require(\n", + " [\"base/js/dialog\"], \n", + " function(dialog) {\n", + " dialog.modal({\n", + " title: 'Debug',\n", + " body: 'Please close viewer window before continuing',\n", + " buttons: {\n", + " 'Close': {}\n", + " }\n", + " });\n", + " }\n", + " );\n", + " \"\"\"))\n", + " im.show()\n", + " \n", + "\n", + "#generate(0.95, 'irish_setter', [716257571, 216337755, 602801999, 1027629257])\n", + "generate(0.95, 'barn', [237774802, 1498010115, 105741908, 857168362, 639216961])\n", + "#generate(0.95, 'coral_reef')\n", + "#generate(0.95, 'lighthouse', [1573600108])\n", + "#generate(0.95, 'seashore', [1891640828, 130794492, 1321047179, 750963629])\n", + "generate(0.95, 'castle', [995150904, 530702035])\n", + "#generate(0.95, 'golden_retriever', [])\n", + "#generate(0.95, 'goldfinch', [])\n", + "#generate(0.95, 'indigo_bunting', [1624898412])\n", + "#generate(0.95, 'red_wine', [])\n", + "#generate(0.95, 'anemone_fish', [11610217])\n", + "#generate(0.95, 'earthstar', [])\n", + "#generate(0.95, 'beer_bottle', [485603871, 527619953])\n", + "#generate(0.8, 'beer_glass', [])\n", + "#generate(0.95, 'church', [628962584, 1700971930]) # , 371570218, 1137007398, 1412786664\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Show every layer for given content and style pair\n", + "def blend(cls, seed1, seed2):\n", + " inst.remove_edits()\n", + " model.set_output_class(cls)\n", + " z1 = model.sample_latent(seed=seed1)\n", + " z2 = model.sample_latent(seed=seed2)\n", + "\n", + " out1 = model.sample_np(z1)\n", + " out2 = model.sample_np(z2)\n", + "\n", + " intermed = []\n", + " for layer in range(0, 6, 1):\n", + " inst.close()\n", + " inst.remove_edits()\n", + " layer_name = f'generator.layers.{layer}'\n", + " inst.retain_layer(layer_name)\n", + "\n", + " # Content features up to layer\n", + " model.partial_forward(z1, layer_name)\n", + " feat = inst.retained_features()[layer_name].detach()\n", + "\n", + " # New style\n", + " inst.edit_layer(layer_name, ablation=1.0, replacement=feat)\n", + " intermed.append(model.sample_np(z2))\n", + "\n", + " imgs = np.hstack([out1] + intermed[::-1] + [out2])\n", + " im = Image.fromarray((imgs*255).astype(np.uint8))\n", + " im.save(f'out/{cls}_style_layer_comp.png')\n", + "\n", + " # Style blending by latent interpolation (does not keep geometry consistent)\n", + " inst.remove_edits()\n", + " lerp = lambda x,y,a : a*x+(1-a)*y\n", + " imgs_latent_interp = []\n", + " for a in np.linspace(0.0, 1.0, 8):\n", + " z = lerp(z2, z1, a)\n", + " imgs_latent_interp.append(model.sample_np(z))\n", + "\n", + " imgs_latent_interp = np.hstack(imgs_latent_interp)\n", + " im = Image.fromarray((imgs_latent_interp*255).astype(np.uint8))\n", + " im.save(f'out/{cls}_style_latent_comp.png')\n", + "\n", + "\n", + "blend('castle', 995150904, 1171165061)\n", + "blend('church', 628962584, 1700971930)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/figure_biggan_style_resampling.ipynb b/notebooks/figure_biggan_style_resampling.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..569d5ac61fe887a70d324915fbeda9320382e687 --- /dev/null +++ b/notebooks/figure_biggan_style_resampling.ipynb @@ -0,0 +1,112 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Copyright 2020 Erik Härkönen. All rights reserved.\n", + "# This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n", + "# you may not use this file except in compliance with the License. You may obtain a copy\n", + "# of the License at http://www.apache.org/licenses/LICENSE-2.0\n", + "\n", + "# Unless required by applicable law or agreed to in writing, software distributed under\n", + "# the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n", + "# OF ANY KIND, either express or implied. See the License for the specific language\n", + "# governing permissions and limitations under the License.\n", + "\n", + "%matplotlib inline\n", + "from notebook_init import *\n", + "\n", + "out_root = Path('out/figures/biggan_style')\n", + "makedirs(out_root, exist_ok=True)\n", + "\n", + "model = get_model('BigGAN-512', 'husky', device)\n", + "rand = lambda : np.random.randint(np.iinfo(np.int32).max)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "classes = ['husky', 'church']\n", + "base_seeds = [665823877, 419650361]\n", + "style_seeds = [1922988331, 286873059, 1376693511, 1853453896]\n", + "print(base_seeds, style_seeds)\n", + "\n", + "num_keep = [1, 4, 8] # switch latent after first, fourth, and eighth layer\n", + "layer_names = ['layer1', 'layer4', 'layer8']\n", + "\n", + "model.truncation = 0.9\n", + "\n", + "for class_idx, class_name in enumerate(classes):\n", + " print(class_name, base_seeds[class_idx])\n", + " \n", + " model.set_output_class(class_name)\n", + " \n", + " for n_base in num_keep:\n", + " strip = []\n", + " \n", + " # Base\n", + " z0 = model.sample_latent(1, seed=base_seeds[class_idx])\n", + " out = model.sample_np(z0)\n", + " \n", + " # Resample style\n", + " plt.figure(figsize=(25,25))\n", + " for img_idx, seed in enumerate(style_seeds):\n", + " z1 = model.sample_latent(1, seed=seed)\n", + " \n", + " # Use style latent after 'n_base' layers\n", + " n_style = model.get_max_latents() - n_base\n", + " z = [z0] * n_base + [z1] * n_style\n", + " \n", + " img = model.sample_np(z)\n", + " strip.append(img)\n", + " \n", + " # Save individually\n", + " layer_name = f'layer{n_base}'\n", + " img_name = out_root / f'style_resample_{class_name}_{layer_name}_{img_idx}.png'\n", + " im = Image.fromarray((255*img).astype(np.uint8))\n", + " im.save(img_name)\n", + " \n", + " # Show strip\n", + " plt.imshow(np.hstack(strip))\n", + " plt.axis('off')\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/figure_edit_zoo.ipynb b/notebooks/figure_edit_zoo.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..762c6eb5e808ba75d433bc929b1eab94f8d5eba9 --- /dev/null +++ b/notebooks/figure_edit_zoo.ipynb @@ -0,0 +1,360 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Copyright 2020 Erik Härkönen. All rights reserved.\n", + "# This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n", + "# you may not use this file except in compliance with the License. You may obtain a copy\n", + "# of the License at http://www.apache.org/licenses/LICENSE-2.0\n", + "\n", + "# Unless required by applicable law or agreed to in writing, software distributed under\n", + "# the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n", + "# OF ANY KIND, either express or implied. See the License for the specific language\n", + "# governing permissions and limitations under the License.\n", + "\n", + "%matplotlib inline\n", + "from notebook_init import *\n", + "from tqdm import trange\n", + "\n", + "out_root = Path('out/directions')\n", + "makedirs(out_root, exist_ok=True)\n", + "B = 5" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "# Model, layer, edit, layer_start, layer_end, class, sigma, idx, name, (example seeds)\n", + "configs = [ \n", + " ### StyleGAN2 cars\n", + "\n", + " # In paper\n", + " ('StyleGAN2', 'style', 'latent', 'w', 8, 9, 'car', 20.0, 50, 'Autumn', [329004386]),\n", + " ('StyleGAN2', 'style', 'latent', 'w', 0, 4, 'car', -10, 15, 'Focal lendth', [587218105, 361309542, 1355448359]),\n", + " ('StyleGAN2', 'style', 'latent', 'w', 0, 9, 'car', 18.5, 44, 'Car model', [1204444821]),\n", + " ('StyleGAN2', 'style', 'latent', 'w', 7, 9, 'car', 20.0, 18, 'Reflections', [1498448887]),\n", + " \n", + " # Other\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 9, 11, 'car', -20.0, 41, 'Add grass', [257249032]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 0, 5, 'car', -2.7, 0, 'Horizontal flip', [1221001524]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 7, 16, 'car', 20.0, 50, 'Fall foliage', [1108802786]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 8, 9, 'car', -14.0, 29, 'Blown out highlight', [490151100, 1010645708]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 0, 4, 'car', 12, 13, 'Flat vs tall', [1541814754, 1355448359]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 5, 6, 'car', 20.0, 32, 'Front wheel turn', [1060866846]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 9, 10, 'car', -20.0, 35, 'Ground smoothness', [1920211941]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 7, 16, 'car', 20.0, 37, 'Image contrast', [1419881462]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 9, 11, 'car', -20.0, 45, 'Sepia', [105288903]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 7, 16, 'car', 20.0, 38, 'Sunset', [1419881462]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 0, 5, 'car', -2.0, 1, 'Side to front', [1221001524]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 3, 7, 'car', -7.5, 10, 'Sports car', [743765988]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 8, 9, 'car', 5.3, 14, 'White car', [1355448359]),\n", + " \n", + "\n", + " ### StyleGAN2 ffhq\n", + "\n", + " # In paper\n", + " ('StyleGAN2', 'style', 'latent', 'w', 6, 8, 'ffhq', -20.0, 43, 'Disgusted', [140658858, 1887645531]),\n", + " ('StyleGAN2', 'style', 'latent', 'w', 8, 9, 'ffhq', 9.0, 0, 'Makeup', [266415229, 375122892]),\n", + "\n", + " # Other\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 4, 5, 'ffhq', 10.0, 19, 'Big smile', [427229260]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 6, 8, 'ffhq', -20.0, 33, 'Scary eyes', [1887645531]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 2, 5, 'ffhq', 18.2, 21, 'Bald', [1635892780]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 8, 9, 'ffhq', 13.0, 13, 'Bright BG vs FG', [798602383]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 3, 6, 'ffhq', -60.0, 47, 'Curly hair', [1140578688]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 8, 9, 'ffhq', -10.2, 16, 'Hair albedo', [427229260]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 4, 7, 'ffhq', 10.0, 36, 'Displeased', [1887645531]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 8, 9, 'ffhq', 20.0, 37, 'Eyebrow thickness', [1887645531]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 7, 8, 'ffhq', -30.0, 54, 'Eye openness', [11573701]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 0, 5, 'ffhq', 20.0, 37, 'Face roundness', [1887645531]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 4, 10, 'ffhq', -20.0, 54, 'Fearful eyes', [11573701]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 4, 5, 'ffhq', -13.6, 21, 'Hairline', [1635892780]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 0, 8, 'ffhq', 20.0, 30, 'Happy frizzy hair', [1887645531]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 1, 4, 'ffhq', -10.5, 11, 'Head angle up', [798602383]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 3, 6, 'ffhq', -15.0, 23, 'In awe', [1635892780]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 3, 6, 'ffhq', -15.0, 22, 'Large jaw', [1635892780]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 10, 11, 'ffhq', 20.0, 34, 'Lipstick', [1887645531]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 4, 5, 'ffhq', -30.0, 51, 'Nose length', [11573701]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 8, 18, 'ffhq', 5.0, 27, 'Overexposed', [1887645531]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 3, 7, 'ffhq', -14.5, 35, 'Screaming', [1887645531]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 2, 6, 'ffhq', -20.0, 32, 'Short face', [1887645531]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 4, 5, 'ffhq', -20.0, 46, 'Smile', [1175071341]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 4, 5, 'ffhq', -20.0, 20, 'Unhappy bowl cut', [1635892780]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 8, 9, 'ffhq', -8.0, 10, 'Sunlight in face', [798602383]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 7, 9, 'ffhq', -40.0, 58, 'Trimmed beard', [1602858467]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 3, 5, 'ffhq', -9.0, 20, 'Forehead hair', [1382206226]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 0, 5, 'ffhq', -9.0, 21, 'Happy frizzy hair', [1382206226]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 8, 9, 'ffhq', -15.0, 25, 'Light UD', [1382206226]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 8, 11, 'ffhq', 9.0, 0, 'Makeup', [1953272274]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 4, 6, 'ffhq', -16.0, 36, 'Smile', [1382206226]),\n", + "\n", + "\n", + " ### StyleGAN2 horse\n", + "\n", + " # In paper\n", + " ('StyleGAN2', 'style', 'latent', 'w', 3, 5, 'horse', -2.9, 3, 'Add rider', [944988831]),\n", + " ('StyleGAN2', 'style', 'latent', 'w', 5, 7, 'horse', -7.8, 11, 'Coloring', [897830797]),\n", + "\n", + " # Other\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 7, 9, 'horse', 11.8, 20, 'White horse', [1042666993]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 9, 11, 'horse', 9.0, 8, 'Green bg', [897830797]),\n", + " \n", + "\n", + " ### StyleGAN2 cat\n", + "\n", + " # In paper\n", + " ('StyleGAN2', 'style', 'latent', 'w', 5, 8, 'cat', 20.0, 45, 'Eyes closed', [81011138]),\n", + " ('StyleGAN2', 'style', 'latent', 'w', 2, 5, 'cat', 20.0, 27, 'Fluffiness', [740196857]),\n", + " \n", + " # Other\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 0, 6, 'cat', 20.0, 18, 'Head dist 2', [2021386866]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 8, 9, 'cat', 12.7, 28, 'Light pos', [740196857]),\n", + " \n", + "\n", + " ### StyleGAN2 church\n", + "\n", + " # In paper\n", + " ('StyleGAN2', 'style', 'latent', 'w', 7, 9, 'church', -20.0, 20, 'Clouds', [1360331956, 485108354]),\n", + " ('StyleGAN2', 'style', 'latent', 'w', 7, 9, 'church', -8.4, 8, 'Direct sunlight', [1777321344, 38689046]),\n", + " ('StyleGAN2', 'style', 'latent', 'w', 8, 9, 'church', 20.0, 15, 'Sun direction', [485108354]),\n", + " ('StyleGAN2', 'style', 'latent', 'w', 12, 14, 'church', -20.0, 8, 'Vibrant', [373098621, 38689046]),\n", + "\n", + " # Other\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 9, 14, 'church', 9.9, 11, 'Blue skies', [1003401116]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 5, 7, 'church', -20.0, 20, 'Clouds 2', [1360331956, 485108354]),\n", + " # ('StyleGAN2', 'style', 'latent', 'w', 5, 6, 'church', -19.1, 12, 'Trees', [1344303167]),\n", + " \n", + "\n", + " ### StyleGAN1 bedrooms\n", + "\n", + " # In paper\n", + " ('StyleGAN', 'g_mapping', 'latent', 'w', 0, 6, 'bedrooms', 18.5, 31, 'flat_vs_tall', [2073683729]),\n", + " ('StyleGAN', 'g_mapping', 'latent', 'w', 0, 3, 'bedrooms', -2.6, 5, 'Bed pose', [96357868]),\n", + " \n", + "\n", + " ### StyleGAN1 wikiart\n", + "\n", + " # In paper\n", + " ('StyleGAN', 'g_mapping', 'latent', 'w', 0, 2, 'wikiart', -2.9, 7, 'Head rotation', [1819967864]),\n", + " ('StyleGAN', 'g_mapping', 'latent', 'w', 8, 15, 'wikiart', 7.5, 9, 'Simple strokes', [1239190942]),\n", + " ('StyleGAN', 'g_mapping', 'latent', 'w', 9, 15, 'wikiart', -20.0, 59, 'Skin tone', [1615931059, 1719766582]),\n", + " ('StyleGAN', 'g_mapping', 'latent', 'w', 4, 7, 'wikiart', 20.0, 36, 'Mouth shape', [333293845]),\n", + " ('StyleGAN', 'g_mapping', 'latent', 'w', 2, 4, 'wikiart', -35.0, 35, 'Eye spacing', [1213732031, 333293856]),\n", + " ('StyleGAN', 'g_mapping', 'latent', 'w', 8, 15, 'wikiart', 20.0, 31, 'Sharpness', [1489906162, 1768450051]),\n", + "\n", + " # Other\n", + " # ('StyleGAN', 'g_mapping', 'latent', 'w', 4, 7, 'wikiart', -16.3, 25, 'Open mouth', [1655670048]),\n", + " # ('StyleGAN', 'g_mapping', 'latent', 'w', 10, 16, 'wikiart', -20.0, 18, 'Rough strokes', [1942295817]),\n", + " # ('StyleGAN', 'g_mapping', 'latent', 'w', 1, 4, 'wikiart', -7.2, 14, 'Camera UD', [1136416437]),\n", + " # ('StyleGAN', 'g_mapping', 'latent', 'w', 8, 14, 'wikiart', -8.4, 13, 'Stroke contrast', [1136416437]),\n", + " # ('StyleGAN', 'g_mapping', 'latent', 'w', 4, 7, 'wikiart', 20.0, 44, 'Eye size', [333293845]),\n", + " # ('StyleGAN', 'g_mapping', 'latent', 'w', 4, 8, 'wikiart', 13.9, 16, 'Open mouth', [2135985383]),\n", + " # ('StyleGAN', 'g_mapping', 'latent', 'w', 10, 15, 'wikiart', 20.0, 26, 'Sharpness 2', [1489906162, 1223183477]),\n", + " # ('StyleGAN', 'g_mapping', 'latent', 'w', 9, 14, 'wikiart', 20.0, 32, 'Splotchy', [1768450051]),\n", + " \n", + "\n", + " ### BigGAN-512\n", + " \n", + " # In paper\n", + " ('BigGAN-512', 'generator.gen_z', 'latent', 'z', 6, 10, 'red_fox', -20.0, 64, 'Add grass', [20736816]),\n", + " ('BigGAN-512', 'generator.gen_z', 'latent', 'z', 6, 15, 'barn', 9.0, 54, 'Hight contrast clouds', [1826867440]),\n", + " ('BigGAN-512', 'generator.gen_z', 'latent', 'z', 6, 15, 'leopard', -9.0, 37, 'Moonlight', [1202948959]),\n", + " ('BigGAN-512', 'generator.gen_z', 'latent', 'z', 3, 15, 'husky', -9.0, 62, 'Season', [1162727876]),\n", + "\n", + " # Other\n", + " # ('BigGAN-512', 'generator.gen_z', 'latent', 'z', 4, 13, 'barn', 9.0, 51, 'Cloudy', [1516873095]),\n", + " # ('BigGAN-512', 'generator.gen_z', 'latent', 'z', 5, 15, 'leopard', 9.0, 30, 'Dark bg', [1345197166]),\n", + " # ('BigGAN-512', 'generator.gen_z', 'latent', 'z', 3, 12, 'red_fox', 11.8, 57, 'Dry ground', [1426778692]),\n", + " # ('BigGAN-512', 'generator.gen_z', 'latent', 'z', 6, 15, 'leopard', -9.0, 41, 'Evening', [337748435]),\n", + " # ('BigGAN-512', 'generator.gen_z', 'latent', 'z', 3, 7, 'husky', 9.0, 69, 'Grass bg', [701138437]),\n", + " # ('BigGAN-512', 'generator.gen_z', 'latent', 'z', 0, 15, 'leopard', -4.9, 2, 'Head hight', [696403469]),\n", + " # ('BigGAN-512', 'generator.gen_z', 'latent', 'z', 5, 10, 'red_fox', 20.0, 53, 'Large leaves', [1426778692]),\n", + " # ('BigGAN-512', 'generator.gen_z', 'latent', 'z', 8, 9, 'husky', -20.0, 67, 'Lit up face', [513373036]),\n", + " # ('BigGAN-512', 'generator.gen_z', 'latent', 'z', 12, 13, 'husky', 50.0, 46, 'Local contrast', [489408324]),\n", + " # ('BigGAN-512', 'generator.gen_z', 'latent', 'z', 0, 4, 'leopard', -4.9, 12, 'On rock', [2044716610]),\n", + " # ('BigGAN-512', 'generator.gen_z', 'latent', 'z', 4, 15, 'leopard', 9.0, 49, 'Orange foilage', [510622299]),\n", + " # ('BigGAN-512', 'generator.gen_z', 'latent', 'z', 10, 11, 'leopard', -9.0, 46, 'Pixelated', [109524934]),\n", + " # ('BigGAN-512', 'generator.gen_z', 'latent', 'z', 10, 11, 'leopard', 9.0, 43, 'Pixelated 2', [109524934]),\n", + " # ('BigGAN-512', 'generator.gen_z', 'latent', 'z', 4, 13, 'barn', -9.0, 48, 'Colorful sky', [1516873095]),\n", + " # ('BigGAN-512', 'generator.gen_z', 'latent', 'z', 6, 15, 'barn', 9.0, 65, 'Red barn', [1289115451]),\n", + " # ('BigGAN-512', 'generator.gen_z', 'latent', 'z', 0, 15, 'leopard', -1.4, 3, 'Rotation 2', [696403469]),\n", + " # ('BigGAN-512', 'generator.gen_z', 'latent', 'z', 14, 15, 'husky', 50.0, 46, 'Sharpness', [489408324]),\n", + " # ('BigGAN-512', 'generator.gen_z', 'latent', 'z', 3, 4, 'husky', -20.0, 57, 'Show tongue', [489408324]),\n", + " # ('BigGAN-512', 'generator.gen_z', 'latent', 'z', 5, 15, 'barn', -9.0, 44, 'Trees', [2121410149]),\n", + " # ('BigGAN-512', 'generator.gen_z', 'latent', 'z', 4, 9, 'leopard', -9.0, 28, 'White bg', [1345197166]),\n", + " # ('BigGAN-512', 'generator.gen_z', 'latent', 'z', 11, 14, 'husky', 20.0, 54, 'Washed out', [489408324]),\n", + "]\n", + "\n", + "has_gpu = torch.cuda.is_available()\n", + "device = torch.device('cuda' if has_gpu else 'cpu')\n", + "\n", + "num_imgs_per_example = 1\n", + "\n", + "for config_id, (model_name, layer, mode, latent_space, l_start, l_end, classname, sigma, idx, title, seeds) in enumerate(configs[:]):\n", + " print(f'{model_name}, {layer}, {title}')\n", + " \n", + " inst = get_instrumented_model(model_name, classname, layer, device, inst=inst) # reuse if possible\n", + " model = inst.model\n", + " \n", + " if 'BigGAN' in model_name:\n", + " model.truncation = 0.6\n", + " elif 'StyleGAN2' in model_name:\n", + " model.truncation = 0.7\n", + " \n", + " if latent_space == 'w':\n", + " model.use_w()\n", + " elif hasattr(model, 'use_z'):\n", + " model.use_z()\n", + " \n", + " # Load or compute decomposition\n", + " config = Config(\n", + " output_class = classname,\n", + " model = model_name,\n", + " layer = layer,\n", + " estimator = 'ipca',\n", + " use_w = (latent_space == 'w'),\n", + " n = 1_000_000\n", + " )\n", + "\n", + " # Special case: BigGAN512-deep, gen_z: class-independent\n", + " if model_name == 'BigGAN-512' and layer == 'generator.gen_z':\n", + " config.output_class = 'husky' # chosen class doesn't matter\n", + " \n", + " dump_name = get_or_compute(config, inst)\n", + " data = np.load(dump_name, allow_pickle=False)\n", + " X_comp = data['act_comp']\n", + " X_global_mean = data['act_mean']\n", + " X_stdev = data['act_stdev']\n", + " Z_global_mean = data['lat_mean']\n", + " Z_comp = data['lat_comp']\n", + " Z_stdev = data['lat_stdev']\n", + " data.close()\n", + "\n", + " model.set_output_class(classname)\n", + " feat_shape = X_comp[0].shape\n", + " sample_dims = np.prod(feat_shape)\n", + " \n", + " # Transfer to GPU\n", + " components = SimpleNamespace(\n", + " X_comp = torch.from_numpy(X_comp).view(-1, *feat_shape).to('cuda').float(), #-1, 1, C, H, W\n", + " X_global_mean = torch.from_numpy(X_global_mean).view(*feat_shape).to('cuda').float(), # 1, C, H, W\n", + " X_stdev = torch.from_numpy(X_stdev).to('cuda').float(),\n", + " Z_comp = torch.from_numpy(Z_comp).to('cuda').float(),\n", + " Z_stdev = torch.from_numpy(Z_stdev).to('cuda').float(),\n", + " Z_global_mean = torch.from_numpy(Z_global_mean).to('cuda').float(),\n", + " )\n", + " \n", + " num_seeds = ((num_imgs_per_example - 1) // B + 1) * B # make divisible\n", + " max_seed = np.iinfo(np.int32).max\n", + " seeds = np.concatenate((seeds, np.random.randint(0, max_seed, num_seeds)))\n", + " seeds = seeds[:num_seeds].astype(np.int32)\n", + " latents = [model.sample_latent(1, seed=s) for s in seeds]\n", + " \n", + " # Range is exclusive, in contrast to notation in paper\n", + " edit_start = l_start\n", + " edit_end = model.get_max_latents() if l_end == -1 else l_end\n", + " \n", + " batch_frames = create_strip_centered(inst, mode, layer, latents, components.X_comp[idx],\n", + " components.Z_comp[idx], components.X_stdev[idx], components.Z_stdev[idx],\n", + " components.X_global_mean, components.Z_global_mean, sigma, edit_start, edit_end)\n", + " #save_frames(f'{config_id}_{title}_{mode}', model_name, out_root, batch_frames)\n", + " \n", + " edit_name = prettify_name(title)\n", + " outidr = out_root / model_name / classname / edit_name\n", + " makedirs(outidr, exist_ok=True)\n", + "\n", + " for ex, frames in enumerate(batch_frames):\n", + " for i, frame in enumerate(frames):\n", + " Image.fromarray(np.uint8(frame*255)).save(outidr / f'cmp{idx}_s{edit_start}_e{edit_end}_{seeds[ex]}_{i}.png')\n", + "\n", + " # Show first\n", + " plt.figure(figsize=(15,15))\n", + " plt.imshow(np.hstack(pad_frames(batch_frames[0])))\n", + " plt.axis('off')\n", + " plt.show()\n", + "\n", + "print('Done')\n", + " \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Convert saved directions to textual form (for pasting in cell above)\n", + "\n", + "templ = \"{active}('{model_name}', '{layer}', '{edit_type}', '{latent_space}', {edit_start}, {edit_end}, '{out_class}', {sigma}, {comp_idx}, '{description}', [{seeds}]),\"\n", + "def textual_repr(dump):\n", + " comp_cls = dump['decomposition']['class_name'] # PCA computed from\n", + " appl_cls = dump['output_class'] # components applied onto\n", + " \n", + " return templ.format(\n", + " active = '#' if comp_cls != appl_cls else '', # don't mix\n", + " model_name = dump['model_name'],\n", + " layer = dump['decomposition']['layer'],\n", + " edit_type = dump['edit_type'],\n", + " latent_space = dump['latent_space'].lower(),\n", + " edit_start = dump['edit_start'],\n", + " edit_end = dump['edit_end'],\n", + " out_class = comp_cls,\n", + " sigma = dump['sigma_range'],\n", + " comp_idx = dump['component_index'],\n", + " description = dump['name'],\n", + " seeds = dump['example_seed']\n", + " )\n", + "\n", + "import pickle\n", + "import glob\n", + "\n", + "dumps_root = Path('../out/directions')\n", + "config_files = glob.glob(f'{dumps_root.resolve()}/*.pkl')\n", + "\n", + "for config_id, dump_path in enumerate(config_files):\n", + " with open(dump_path, 'rb') as f:\n", + " data = pickle.load(f)\n", + " desc = textual_repr(data)\n", + " print(desc)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.5-final" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} \ No newline at end of file diff --git a/notebooks/figure_first_20_pcs.ipynb b/notebooks/figure_first_20_pcs.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..317e775c8dcd1a8dc2bd16328da264cf35fe948e --- /dev/null +++ b/notebooks/figure_first_20_pcs.ipynb @@ -0,0 +1,303 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Copyright 2020 Erik Härkönen. All rights reserved.\n", + "# This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n", + "# you may not use this file except in compliance with the License. You may obtain a copy\n", + "# of the License at http://www.apache.org/licenses/LICENSE-2.0\n", + "\n", + "# Unless required by applicable law or agreed to in writing, software distributed under\n", + "# the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n", + "# OF ANY KIND, either express or implied. See the License for the specific language\n", + "# governing permissions and limitations under the License.\n", + "\n", + "%matplotlib inline\n", + "from notebook_init import *\n", + "import scipy\n", + "\n", + "out_root = Path('out/figures/first_20_pcs')\n", + "makedirs(out_root, exist_ok=True)\n", + "rand = lambda : np.random.randint(np.iinfo(np.int32).max)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def gram_schmidt_cols(V):\n", + " Q, R = np.linalg.qr(V)\n", + " return Q.T\n", + "\n", + "def gram_schmidt_rows(V):\n", + " Q, R = np.linalg.qr(V.T)\n", + " return Q.T\n", + "\n", + "def make_ortho_normal(N=512):\n", + " return scipy.stats.special_ortho_group.rvs(N)\n", + "\n", + "# Components on rows\n", + "def assert_normalized(V):\n", + " assert np.allclose(np.diag(np.dot(V1, V1.T)), np.ones(V1.shape[0])), 'Basis not normalized'\n", + "\n", + "# V = [n_comp, n_dim]\n", + "def assert_orthonormal(V):\n", + " M = np.dot(V, V.T) # [n_comp, n_comp]\n", + " det = np.linalg.det(M)\n", + " assert np.allclose(M, np.identity(M.shape[0]), atol=1e-5), f'Basis is not orthonormal (det={det})'" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "n_pcs = 20\n", + "inst = None\n", + "\n", + "def generate(model, basis, stds, mean, seeds, name, scale=2.0):\n", + " makedirs(out_root / name, exist_ok=True)\n", + " for seed in seeds:\n", + " print(seed)\n", + " \n", + " strips = []\n", + " \n", + " for i in range(n_pcs):\n", + " z = model.sample_latent(1, seed=seed)\n", + " batch_frames = create_strip_centered(inst, 'latent', 'style', [z],\n", + " 0, basis[i], 0, stds[i], 0, mean, scale, 0, 18, num_frames=5)[0]\n", + " strips.append(np.hstack(pad_frames(batch_frames, pad_fract_horiz=32)))\n", + " #for j, frame in enumerate(batch_frames):\n", + " # Image.fromarray(np.uint8(frame*255)).save(out_root / name / f'{seed}_comp{i}_{j}.png')\n", + " \n", + " for i, strip in enumerate(strips):\n", + " Image.fromarray(np.uint8(strip*255)).save(out_root / name / f'{seed}_comp{i}.png', compress_level=1) # converted to jpg for paper\n", + "\n", + " grid = np.vstack(strips)\n", + " \n", + " im = Image.fromarray(np.uint8(grid*255))\n", + " im.resize((im.width // 2, im.height // 2)).save(out_root / name / f'grid_{seed}.jpg', compress_level=1)\n", + " \n", + " plt.figure(figsize=(20,40))\n", + " plt.title(name)\n", + " plt.imshow(grid)\n", + " plt.axis('off')\n", + " plt.show()\n", + "\n", + "def get_comp(config, inst):\n", + " classname = config.output_class\n", + " \n", + " # BigGAN components are class agnostic\n", + " # => use precomputed husky components\n", + " if 'BigGAN' in inst.model.model_name:\n", + " config.output_class = 'husky'\n", + " \n", + " dump = get_or_compute(config, inst)\n", + " config.output_class = classname # restore\n", + "\n", + " return dump\n", + "\n", + "def gen_principal_components(config, seeds, name, scale=2):\n", + " global inst\n", + " inst = get_instrumented_model(config, device, inst=inst)\n", + " dump_name = get_comp(config, inst)\n", + "\n", + " model = inst.model\n", + " model.truncation = 1.0\n", + "\n", + " with np.load(dump_name) as data:\n", + " lat_comp = torch.from_numpy(data['lat_comp']).to(device)\n", + " lat_mean = torch.from_numpy(data['lat_mean']).to(device)\n", + " lat_std = data['lat_stdev']\n", + "\n", + " generate(model, lat_comp, lat_std, lat_mean, seeds, f'{name}_{int(scale)}sigma', scale)\n", + "\n", + "def gen_normal_w_ortho(config, seeds, name, scale=2):\n", + " global inst\n", + " inst = get_instrumented_model(config, device, inst=inst)\n", + " dump_name = get_comp(config, inst)\n", + " \n", + " model = inst.model\n", + " model.truncation = 1.0\n", + "\n", + " with np.load(dump_name) as data:\n", + " mean = torch.from_numpy(data['lat_mean']).to(device)\n", + "\n", + " n_comp = model.get_latent_dims() # full rank basis\n", + " V = make_ortho_normal(n_comp)\n", + " assert_orthonormal(V)\n", + "\n", + " comp = torch.from_numpy(V).float().unsqueeze(dim=1).to(device)\n", + " stdev = torch.ones((n_comp,)).float().to(device)\n", + "\n", + " generate(model, comp, stdev, mean, seeds, f'{name}_{int(scale)}x', scale)\n", + "\n", + "# Pseudo-PCA ablation: basis highly shaped by W\n", + "def gen_w_ortho_ablation(config, seeds, name, scale=2):\n", + " global inst\n", + " inst = get_instrumented_model(config, device, inst=inst)\n", + " dump_name = get_comp(config, inst)\n", + " \n", + " model = inst.model\n", + " model.truncation = 1.0\n", + "\n", + " with np.load(dump_name) as data:\n", + " mean = torch.from_numpy(data['lat_mean']).to(device)\n", + " stdev = torch.from_numpy(data['lat_stdev']).to(device) # use PCA stdevs with random W dirs\n", + "\n", + " n_comp = model.get_latent_dims() # full rank\n", + " V = (model.sample_latent(n_comp, seed=0) - mean).cpu().numpy() # [n_comp, n_dim]\n", + " V = V / np.sqrt(np.sum(V*V, axis=-1, keepdims=True)) # normalize rows\n", + " V = gram_schmidt_rows(V)\n", + " assert_orthonormal(V)\n", + "\n", + " comp = torch.from_numpy(V).float().unsqueeze(dim=1).to(device)\n", + " generate(model, comp, stdev, mean, seeds, f'{name}_{int(scale)}_pc_sigmas', scale)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [], + "source": [ + "seeds = [366745668] # 1502970553, 1235907362, 1302626592]\n", + "\n", + "# StyleGAN2 ffhq\n", + "cfg = Config(components=512, n=1_000_000, batch_size=10_000, use_w=True,\n", + " layer='style', model='StyleGAN2', output_class='ffhq')\n", + "\n", + "#gen_principal_components(cfg, seeds, 'stylegan2_ffhq_pca')\n", + "#gen_normal_w_ortho(cfg, seeds, 'stylegan2_ffhq_random', scale=6)\n", + "#gen_w_ortho_ablation(cfg, seeds, 'stylegan2_ffhq_ablation')\n", + "\n", + "# Switch to Z latent space\n", + "cfg.use_w = False\n", + "gen_normal_w_ortho(cfg, seeds, 'stylegan2_ffhq_random_z', scale=10)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false, + "tags": [] + }, + "outputs": [], + "source": [ + "seeds = [697477267] # 901810270, 101052884, 794859404, 1459915324\n", + "\n", + "# StyleGAN2 car\n", + "cfg = Config(components=512, n=1_000_000, batch_size=10_000, use_w=True,\n", + " layer='style', model='StyleGAN2', output_class='car')\n", + "#gen_principal_components(cfg, seeds, 'stylegan2_car_pca')\n", + "gen_normal_w_ortho(cfg, seeds, 'stylegan2_car_random', scale=8)\n", + "#gen_w_ortho_ablation(cfg, seeds, 'stylegan2_car_ablation')\n", + "\n", + "# Switch to Z latent space\n", + "cfg.use_w = False\n", + "gen_normal_w_ortho(cfg, seeds, 'stylegan2_car_random_z', scale=10)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [], + "source": [ + "seeds = [1285057649] #1526046390, 1762862368\n", + "\n", + "# StyleGAN2 cat\n", + "cfg = Config(components=512, n=1_000_000, batch_size=10_000, use_w=True,\n", + " layer='style', model='StyleGAN2', output_class='cat')\n", + "gen_principal_components(cfg, seeds, 'stylegan2_cat_pca')\n", + "gen_normal_w_ortho(cfg, seeds, 'stylegan2_cat_random', scale=10)\n", + "#gen_w_ortho_ablation(cfg, seeds, 'stylegan2_cat_ablation')\n", + "\n", + "# Switch to Z latent space\n", + "cfg.use_w = False\n", + "gen_normal_w_ortho(cfg, seeds, 'stylegan2_cat_random_z', scale=10)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [], + "source": [ + "seeds = [2129808859] #1903883295\n", + "\n", + "# BigGAN-512 husky\n", + "cfg = Config(components=128, n=1_000_000,\n", + " layer='generator.gen_z', model='BigGAN-512', output_class='husky')\n", + "gen_principal_components(cfg, seeds, 'biggan512_husky_pca', scale=2)\n", + "gen_normal_w_ortho(cfg, seeds, 'biggan512_husky_random', scale=6)\n", + "#gen_w_ortho_ablation(cfg, seeds, 'biggan512_husky_ablation', scale=2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "seeds = [844616023]\n", + "\n", + "# BigGAN-512 church\n", + "cfg = Config(components=128, n=1_000_000,\n", + " layer='generator.gen_z', model='BigGAN-512', output_class='church')\n", + "gen_principal_components(cfg, seeds, 'biggan512_church_pca', scale=3)\n", + "gen_normal_w_ortho(cfg, seeds, 'biggan512_church_random', scale=8)\n", + "#gen_w_ortho_ablation(cfg, seeds, 'biggan512_church_ablation', scale=3)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.7-final" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} \ No newline at end of file diff --git a/notebooks/figure_pca_cleanup.ipynb b/notebooks/figure_pca_cleanup.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..4743f76ff81a45688ab95aeafc2e364c7f936a87 --- /dev/null +++ b/notebooks/figure_pca_cleanup.ipynb @@ -0,0 +1,174 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Copyright 2020 Erik Härkönen. All rights reserved.\n", + "# This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n", + "# you may not use this file except in compliance with the License. You may obtain a copy\n", + "# of the License at http://www.apache.org/licenses/LICENSE-2.0\n", + "\n", + "# Unless required by applicable law or agreed to in writing, software distributed under\n", + "# the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n", + "# OF ANY KIND, either express or implied. See the License for the specific language\n", + "# governing permissions and limitations under the License.\n", + "\n", + "# Show top 10 PCs for StyleGAN2 ffhq\n", + "# Center along component before manipulation\n", + "# Also show cleaned up PCs based on top10, a couple of cleaned up later style PCs\n", + "%matplotlib inline\n", + "from notebook_init import *\n", + "\n", + "out_root = Path('out/figures/pca_cleanup')\n", + "makedirs(out_root / 'tuned', exist_ok=True)\n", + "makedirs(out_root / 'global', exist_ok=True)\n", + "rand = lambda : np.random.randint(np.iinfo(np.int32).max)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "use_w = True\n", + "inst = get_instrumented_model('StyleGAN2', 'ffhq', 'style', device, inst=inst, use_w=use_w)\n", + "model = inst.model\n", + "model.truncation = 1.0\n", + "\n", + "pc_config = Config(components=80, n=1_000_000, use_w=use_w,\n", + " layer='style', model='StyleGAN2', output_class='ffhq')\n", + "dump_name = get_or_compute(pc_config, inst)\n", + "\n", + "with np.load(dump_name) as data:\n", + " lat_comp = torch.from_numpy(data['lat_comp']).to(device)\n", + " lat_mean = torch.from_numpy(data['lat_mean']).to(device)\n", + " lat_std = data['lat_stdev']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "seeds_ffhq = [366745668] #, 1502970553, 1235907362, 1302626592]\n", + "#seeds_ffhq = [rand() for _ in range(50)]\n", + "\n", + "n_pcs = 14\n", + "\n", + "# Case 1: Normal centered PCs\n", + "for seed in seeds_ffhq:\n", + " print(seed)\n", + " \n", + " strips = []\n", + " \n", + " for i in range(n_pcs):\n", + " z = model.sample_latent(1, seed=seed)\n", + " batch_frames = create_strip_centered(inst, 'latent', 'style', [z],\n", + " 0, lat_comp[i], 0, lat_std[i], 0, lat_mean, 2.0, 0, 18, num_frames=7)[0]\n", + " strips.append(np.hstack(pad_frames(batch_frames)))\n", + " for j, frame in enumerate(batch_frames):\n", + " Image.fromarray(np.uint8(frame*255)).save(out_root / 'global' / f'{seed}_pc{i}_{j}.png')\n", + " \n", + " #col_left = np.vstack(pad_frames(strips[:n_pcs//2], 0, 64))\n", + " #col_right = np.vstack(pad_frames(strips[n_pcs//2:], 0, 64))\n", + " grid = np.vstack(strips)\n", + " \n", + " Image.fromarray(np.uint8(grid*255)).save(out_root / f'grid_{seed}.jpg')\n", + " \n", + " plt.figure(figsize=(20,40))\n", + " plt.imshow(grid)\n", + " plt.axis('off')\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "# Case 2: hand-tuned layer ranges for some directions\n", + "hand_tuned = [\n", + " ( 0, (1, 7), 2.0), # gender, keep age\n", + " ( 1, (0, 3), 2.0), # rotate, keep gender\n", + " ( 2, (3, 8), 2.0), # gender, keep geometry\n", + " ( 3, (2, 8), 2.0), # age, keep lighting, no hat\n", + " ( 4, (5, 18), 2.0), # background, keep geometry\n", + " ( 5, (0, 4), 2.0), # hat, keep lighting and age\n", + " ( 6, (7, 18), 2.0), # just lighting\n", + " ( 7, (5, 9), 2.0), # just lighting\n", + " ( 8, (1, 7), 2.0), # age, keep lighting\n", + " ( 9, (0, 5), 2.0), # keep lighting\n", + " (10, (7, 9), 2.0), # hair color, keep geom\n", + " (11, (0, 5), 2.0), # hair length, keep color\n", + " (12, (8, 9), 2.0), # light dir lr\n", + "# (12, (4, 10), 2.0), # light position LR\n", + " (13, (0, 6), 2.0), # about the same\n", + "]\n", + "\n", + "for seed in seeds_ffhq:\n", + " print(seed)\n", + " \n", + " strips = []\n", + " \n", + " for i, (s, e), sigma in hand_tuned:\n", + " z = model.sample_latent(1, seed=seed)\n", + " \n", + " batch_frames = create_strip_centered(inst, 'latent', 'style', [z],\n", + " 0, lat_comp[i], 0, lat_std[i], 0, lat_mean, sigma, s, e, num_frames=7)[0]\n", + " strips.append(np.hstack(pad_frames(batch_frames)))\n", + " for j, frame in enumerate(batch_frames):\n", + " Image.fromarray(np.uint8(frame*255)).save(out_root / 'tuned' / f'{seed}_pc{i}_s{s}_e{e}_{j}.png')\n", + " \n", + " #col_left = np.vstack(pad_frames(strips[:len(strips)//2], 0, 64))\n", + " #col_right = np.vstack(pad_frames(strips[len(strips)//2:], 0, 64))\n", + " #grid = np.hstack(pad_frames(strips, 16))\n", + " grid = np.vstack(strips)\n", + " \n", + " Image.fromarray(np.uint8(grid*255)).save(out_root / f'grid_{seed}_tuned.jpg')\n", + " \n", + " plt.figure(figsize=(20,40))\n", + " plt.imshow(grid)\n", + " plt.axis('off')\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/figure_pca_illustration.ipynb b/notebooks/figure_pca_illustration.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..55e13f200187b5425843399e79f53809ac07217a --- /dev/null +++ b/notebooks/figure_pca_illustration.ipynb @@ -0,0 +1,157 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Copyright 2020 Erik Härkönen. All rights reserved.\n", + "# This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n", + "# you may not use this file except in compliance with the License. You may obtain a copy\n", + "# of the License at http://www.apache.org/licenses/LICENSE-2.0\n", + "\n", + "# Unless required by applicable law or agreed to in writing, software distributed under\n", + "# the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n", + "# OF ANY KIND, either express or implied. See the License for the specific language\n", + "# governing permissions and limitations under the License.\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.decomposition import PCA" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def rotMax(degrees):\n", + " theta = np.radians(degrees)\n", + " c, s = np.cos(theta), np.sin(theta)\n", + " return np.array(((c, -s), (s, c)))\n", + "\n", + "pointSize = 6\n", + "colormap = 'spring'" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "np.random.seed(0)\n", + "z = np.random.normal(size=(2,1000))\n", + "\n", + "plt.scatter(z[0,:],z[1,:],c='black', s=pointSize)\n", + "plt.gca().set_aspect('equal', adjustable='box')\n", + "plt.axis('off')\n", + "\n", + "plt.savefig('zplot.pdf')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "R = rotMax(60)\n", + "lam = np.diag([4,1])\n", + "A = R.dot(lam)\n", + "w = A[:,0]\n", + "y = A.dot(z)\n", + "\n", + "plt.scatter(y[0,:],y[1,:],c=z[0,:],s=pointSize)\n", + "plt.gca().set_aspect('equal', adjustable='datalim')\n", + "plt.arrow(0,0,2*w[0],2*w[1], width = 0.1, head_width = 1)\n", + "plt.axis('off')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# perturb z coordinates\n", + "zp = rotMax(-15).dot(z)\n", + "zp = zp + np.random.normal(size=z.shape)\n", + "\n", + "# sigmoid offset\n", + "lam = np.diag([2,1])\n", + "z2 = np.array(lam.dot(zp))\n", + "z2[1,:] = z2[1,:]+6*np.tanh(z2[0,:]*0.5)\n", + "\n", + "# rotate data\n", + "A = rotMax(15).dot(lam)\n", + "y = A.dot(z2)\n", + "\n", + "# PCA \n", + "yt = y.transpose()\n", + "pca = PCA(n_components = 1)\n", + "x = pca.fit_transform(yt)\n", + "w = pca.components_[0]\n", + "if w[0] < 0:\n", + " w = -w\n", + "\n", + "arrow_scale = 10\n", + "\n", + "plt.scatter(y[0,:],y[1,:],s=pointSize,c=x[:,0],cmap=colormap) \n", + "plt.gca().set_aspect('equal', adjustable='datalim')\n", + "plt.arrow(0,0,arrow_scale*w[0],arrow_scale*w[1], width = 0.1, head_width = 1)\n", + "plt.axis('off')\n", + "\n", + "plt.savefig('yplot.pdf')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "u = np.linalg.pinv(x).dot(z.transpose())[0]\n", + "if u[0] < 0:\n", + " u = -u\n", + "\n", + "arrow_scale = 20\n", + "\n", + "plt.scatter(z[0,:],z[1,:],c=x[:,0]/np.max(np.abs(x)*0.91) , s=pointSize, cmap=colormap)\n", + "plt.gca().set_aspect('equal', adjustable='box')\n", + "plt.arrow(0,0,arrow_scale*u[0],arrow_scale*u[1], width = 0.1, head_width = 0.3)\n", + "plt.axis('off')\n", + "plt.colorbar()\n", + "\n", + "plt.savefig('uplot.pdf')\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/figure_style_content_sep.ipynb b/notebooks/figure_style_content_sep.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..f4baa8fe7cf971e9a596dd8ddfd5c384fe8181ee --- /dev/null +++ b/notebooks/figure_style_content_sep.ipynb @@ -0,0 +1,237 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Copyright 2020 Erik Härkönen. All rights reserved.\n", + "# This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n", + "# you may not use this file except in compliance with the License. You may obtain a copy\n", + "# of the License at http://www.apache.org/licenses/LICENSE-2.0\n", + "\n", + "# Unless required by applicable law or agreed to in writing, software distributed under\n", + "# the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n", + "# OF ANY KIND, either express or implied. See the License for the specific language\n", + "# governing permissions and limitations under the License.\n", + "\n", + "%matplotlib inline\n", + "from notebook_init import *\n", + "import scipy\n", + "\n", + "outdir = Path('out/figures/random_baseline')\n", + "makedirs(outdir, exist_ok=True)\n", + "\n", + "# Project tensor 'X' onto orthonormal basis 'comp', return coordinates\n", + "def project_ortho(X, comp):\n", + " N = comp.shape[0]\n", + " coords = (comp.reshape(N, -1) * X.reshape(-1)).sum(dim=1)\n", + " return coords.reshape([N]+[1]*X.ndim)\n", + "\n", + "def show_img(img_np, W=6, H=6):\n", + " #plt.figure(figsize=(W,H))\n", + " plt.axis('off')\n", + " plt.tight_layout()\n", + " plt.imshow(img_np, interpolation='bilinear')\n", + " \n", + "inst = None # reused when possible" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false, + "tags": [] + }, + "outputs": [], + "source": [ + "from torchvision.utils import make_grid\n", + "\n", + "def generate(model_name, class_name, seed=None, trunc=0.6, N=5, use_random_basis=True):\n", + " global inst\n", + " \n", + " config = Config(n=1_000_000, batch_size=500, model=model_name,\n", + " output_class=class_name, use_w=('StyleGAN' in model_name))\n", + " \n", + " if model_name == 'StyleGAN2':\n", + " config.layer = 'style'\n", + " elif model_name == 'StyleGAN':\n", + " config.layer = 'g_mapping'\n", + " else:\n", + " config.layer = 'generator.gen_z'\n", + " config.n = 1_000_000\n", + " config.output_class = 'husky'\n", + " \n", + " inst = get_instrumented_model(config, torch.device('cuda'), inst=inst)\n", + " model = inst.model\n", + "\n", + " K = model.get_latent_dims()\n", + " config.components = K\n", + " \n", + " dump_name = get_or_compute(config, inst)\n", + "\n", + " with np.load(dump_name) as data:\n", + " lat_comp = torch.from_numpy(data['lat_comp']).cuda()\n", + " lat_mean = torch.from_numpy(data['lat_mean']).cuda()\n", + " lat_std = torch.from_numpy(data['lat_stdev']).cuda()\n", + " \n", + " B = 6\n", + " if seed is None:\n", + " seed = np.random.randint(np.iinfo(np.int32).max - B)\n", + " model.truncation = trunc\n", + " \n", + " if 'BigGAN' in model_name:\n", + " model.set_output_class(class_name)\n", + "\n", + " print(f'Seeds: {seed} - {seed+B}')\n", + "\n", + " # Resampling test\n", + " w_base = model.sample_latent(1, seed=seed + B)\n", + " plt.imshow(model.sample_np(w_base))\n", + " plt.axis('off')\n", + " plt.show()\n", + "\n", + " # Resample some components\n", + " def get_batch(indices, basis):\n", + " w_batch = torch.zeros(B, K).cuda()\n", + " coord_base = project_ortho(w_base - lat_mean, basis)\n", + "\n", + " for i in range(B):\n", + " w = model.sample_latent(1, seed=seed + i)\n", + " coords = coord_base.clone()\n", + " coords_resampled = project_ortho(w - lat_mean, basis)\n", + " coords[indices, :, :] = coords_resampled[indices, :, :]\n", + " w_batch[i, :] = lat_mean + torch.sum(coords * basis, dim=0)\n", + "\n", + " return w_batch\n", + "\n", + " def show_grid(w, title):\n", + " out = model.forward(w)\n", + " if class_name == 'car':\n", + " out = out[:, :, 64:-64, :]\n", + " elif class_name == 'cat':\n", + " out = out[:, :, 18:-8, :]\n", + " grid = make_grid(out, nrow=3)\n", + " grid_np = grid.clamp(0, 1).permute(1, 2, 0).cpu().numpy()\n", + " show_img(grid_np)\n", + " plt.title(title)\n", + "\n", + " def save_imgs(w, prefix):\n", + " for i, img in enumerate(model.sample_np(w)):\n", + " if class_name == 'car':\n", + " img = img[64:-64, :, :]\n", + " elif class_name == 'cat':\n", + " img = img[18:-8, :, :]\n", + " outpath = outdir / f'{model_name}_{class_name}' / f'{prefix}_{i}.png'\n", + " makedirs(outpath.parent, exist_ok=True)\n", + " Image.fromarray(np.uint8(img * 255)).save(outpath)\n", + " #print('Saving', outpath)\n", + "\n", + " def orthogonalize_rows(V):\n", + " Q, R = np.linalg.qr(V.T)\n", + " return Q.T\n", + " \n", + " # V = [n_comp, n_dim]\n", + " def assert_orthonormal(V):\n", + " M = np.dot(V, V.T) # [n_comp, n_comp]\n", + " det = np.linalg.det(M)\n", + " assert np.allclose(M, np.identity(M.shape[0]), atol=1e-5), f'Basis is not orthonormal (det={det})'\n", + "\n", + " plt.figure(figsize=((12,6.5) if class_name in ['car', 'cat'] else (12,8)))\n", + " \n", + " # First N fixed\n", + " ind_rand = np.array(range(N, K)) # N -> K rerandomized\n", + " b1 = get_batch(ind_rand, lat_comp)\n", + " plt.subplot(2, 2, 1)\n", + " show_grid(b1, f'Keep {N} first pca -> Consistent pose')\n", + " save_imgs(b1, f'keep_{N}_first_{seed}')\n", + "\n", + " # First N randomized\n", + " ind_rand = np.array(range(0, N)) # 0 -> N rerandomized\n", + " b2 = get_batch(ind_rand, lat_comp)\n", + " plt.subplot(2, 2, 2)\n", + " show_grid(b2, f'Randomize {N} first pca -> Consistent style')\n", + " save_imgs(b2, f'randomize_{N}_first_{seed}')\n", + "\n", + " if use_random_basis:\n", + " # Random orthonormal basis drawn from p(w)\n", + " # Highly shaped by W, sort of a noisy pseudo-PCA\n", + " #V = (model.sample_latent(K, seed=seed + B + 1) - lat_mean).cpu().numpy()\n", + " #V = V / np.sqrt(np.sum(V*V, axis=-1, keepdims=True)) # normalize rows\n", + " #V = orthogonalize_rows(V)\n", + " \n", + " # Isotropic random basis\n", + " V = scipy.stats.special_ortho_group.rvs(K)\n", + " assert_orthonormal(V)\n", + "\n", + " rand_basis = torch.from_numpy(V).float().view(lat_comp.shape).to(device)\n", + " assert rand_basis.shape == lat_comp.shape, f'Shape mismatch: {rand_basis.shape} != {lat_comp.shape}'\n", + "\n", + " ind_perm = range(K)\n", + " else:\n", + " # Just use shuffled PCA basis\n", + " rng = np.random.RandomState(seed=seed)\n", + " perm = rng.permutation(range(K))\n", + " rand_basis = lat_comp[perm, :]\n", + "\n", + " basis_type_str = 'random' if use_random_basis else 'pca_shfl'\n", + "\n", + " # First N random fixed\n", + " ind_rand = np.array(range(N, K)) # N -> K rerandomized\n", + " b3 = get_batch(ind_rand, rand_basis)\n", + " plt.subplot(2, 2, 3)\n", + " show_grid(b3, f'Keep {N} first {basis_type_str} -> Little consistency')\n", + " save_imgs(b3, f'keep_{N}_first_{basis_type_str}_{seed}')\n", + " \n", + " # First N random rerandomized\n", + " ind_rand = np.array(range(0, N)) # 0 -> N rerandomized\n", + " b4 = get_batch(ind_rand, rand_basis)\n", + " plt.subplot(2, 2, 4)\n", + " show_grid(b4, f'Randomize {N} first {basis_type_str} -> Little variation')\n", + " save_imgs(b4, f'randomize_{N}_first_{basis_type_str}_{seed}')\n", + " \n", + " plt.show()\n", + "\n", + "\n", + "# In paper\n", + "generate('StyleGAN2', 'cat', seed=1866827965, trunc=0.55, N=8)\n", + " \n", + "# In supplemental\n", + "generate('StyleGAN', 'bedrooms', seed=1382244162, trunc=1.0, N=10)\n", + "generate('StyleGAN', 'ffhq', seed=598174413, trunc=1.0, N=10)\n", + "generate('BigGAN-256', 'duck', seed=1134462557, trunc=1.0, N=10)\n", + "generate('StyleGAN2', 'car', seed=1257084100, trunc=0.7, N=5)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.7-final" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} \ No newline at end of file diff --git a/notebooks/figure_supervised_comp.ipynb b/notebooks/figure_supervised_comp.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..d0032d65102a1a810d0135cd280d208c57458812 --- /dev/null +++ b/notebooks/figure_supervised_comp.ipynb @@ -0,0 +1,351 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Copyright 2020 Erik Härkönen. All rights reserved.\n", + "# This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n", + "# you may not use this file except in compliance with the License. You may obtain a copy\n", + "# of the License at http://www.apache.org/licenses/LICENSE-2.0\n", + "\n", + "# Unless required by applicable law or agreed to in writing, software distributed under\n", + "# the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n", + "# OF ANY KIND, either express or implied. See the License for the specific language\n", + "# governing permissions and limitations under the License.\n", + "\n", + "# Comparison to GAN steerability and InterfaceGAN\n", + "%matplotlib inline\n", + "from notebook_init import *\n", + "import pickle\n", + "\n", + "out_root = Path('out/figures/steerability_comp')\n", + "makedirs(out_root, exist_ok=True)\n", + "rand = lambda : np.random.randint(np.iinfo(np.int32).max)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def show_strip(frames):\n", + " plt.figure(figsize=(20,20))\n", + " plt.axis('off')\n", + " plt.imshow(np.hstack(pad_frames(frames, 64)))\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "normalize = lambda t : t / np.sqrt(np.sum(t.reshape(-1)**2))\n", + "\n", + "def compute(\n", + " model,\n", + " lat_mean,\n", + " prefix,\n", + " imgclass,\n", + " seeds,\n", + " d_ours,\n", + " l_start,\n", + " l_end,\n", + " scale_ours,\n", + " d_sup, # single or one per layer\n", + " scale_sup,\n", + " center=True\n", + "):\n", + " model.set_output_class(imgclass)\n", + " makedirs(out_root / imgclass, exist_ok=True)\n", + " \n", + " for seed in seeds:\n", + " print(seed)\n", + " deltas = [d_ours, d_sup]\n", + " scales = [scale_ours, scale_sup]\n", + " ranges = [(l_start, l_end), (0, model.get_max_latents())]\n", + " names = ['ours', 'supervised']\n", + "\n", + " for delta, name, scale, l_range in zip(deltas, names, scales, ranges):\n", + " lat_base = model.sample_latent(1, seed=seed).cpu().numpy()\n", + "\n", + " # Shift latent to lie on mean along given direction\n", + " if center:\n", + " y = normalize(d_sup) # assume ground truth\n", + " dotp = np.sum((lat_base - lat_mean) * y, axis=-1, keepdims=True)\n", + " lat_base = lat_base - dotp * y\n", + " \n", + " # Convert single delta to per-layer delta (to support Steerability StyleGAN)\n", + " if delta.shape[0] > 1:\n", + " #print('Unstacking delta')\n", + " *d_per_layer, = delta # might have per-layer scales, don't normalize\n", + " else:\n", + " d_per_layer = [normalize(delta)]*model.get_max_latents()\n", + " \n", + " frames = []\n", + " n_frames = 5\n", + " for a in np.linspace(-1.0, 1.0, n_frames):\n", + " w = [lat_base]*model.get_max_latents()\n", + " for l in range(l_range[0], l_range[1]):\n", + " w[l] = w[l] + a*d_per_layer[l]*scale\n", + " frames.append(model.sample_np(w))\n", + "\n", + " for i, frame in enumerate(frames):\n", + " Image.fromarray(np.uint8(frame*255)).save(\n", + " out_root / imgclass / f'{prefix}_{name}_{seed}_{i}.png')\n", + " \n", + " strip = np.hstack(pad_frames(frames, 64))\n", + " plt.figure(figsize=(12,12))\n", + " plt.imshow(strip)\n", + " plt.axis('off')\n", + " plt.tight_layout()\n", + " plt.title(f'{prefix} - {name}, scale={scale}')\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [], + "source": [ + "# BigGAN-512\n", + "\n", + "inst = get_instrumented_model('BigGAN-512', 'husky', 'generator.gen_z', device, inst=inst)\n", + "model = inst.model\n", + "\n", + "K = model.get_max_latents()\n", + "pc_config = Config(components=128, n=1_000_000,\n", + " layer='generator.gen_z', model='BigGAN-512', output_class='husky')\n", + "dump_name = get_or_compute(pc_config, inst)\n", + "\n", + "with np.load(dump_name) as data:\n", + " lat_comp = data['lat_comp']\n", + " lat_mean = data['lat_mean']\n", + "\n", + "with open('data/steerability/biggan_deep_512/gan_steer-linear_zoom_512.pkl', 'rb') as f:\n", + " delta_steerability_zoom = pickle.load(f)['w_zoom'].reshape(1, 128)\n", + "with open('data/steerability/biggan_deep_512/gan_steer-linear_shiftx_512.pkl', 'rb') as f:\n", + " delta_steerability_transl = pickle.load(f)['w_shiftx'].reshape(1, 128)\n", + "\n", + "# Indices determined by visual inspection\n", + "delta_ours_transl = lat_comp[0]\n", + "delta_ours_zoom = lat_comp[6]\n", + "\n", + "model.truncation = 0.6\n", + "compute(model, lat_mean, 'zoom', 'robin', [560157313], delta_ours_zoom, 0, K, -3.0, delta_steerability_zoom, 5.5)\n", + "compute(model, lat_mean, 'zoom', 'ship', [107715983], delta_ours_zoom, 0, K, -3.0, delta_steerability_zoom, 5.0)\n", + "\n", + "compute(model, lat_mean, 'translate', 'golden_retriever', [552411435], delta_ours_transl, 0, K, -2.0, delta_steerability_transl, 4.5)\n", + "compute(model, lat_mean, 'translate', 'lemon', [331582800], delta_ours_transl, 0, K, -3.0, delta_steerability_transl, 6.0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [], + "source": [ + "# StyleGAN1-ffhq (InterfaceGAN)\n", + "\n", + "inst = get_instrumented_model('StyleGAN', 'ffhq', 'g_mapping', device, use_w=True, inst=inst)\n", + "model = inst.model\n", + "\n", + "K = model.get_max_latents()\n", + "pc_config = Config(components=128, n=1_000_000, use_w=True,\n", + " layer='g_mapping', model='StyleGAN', output_class='ffhq')\n", + "dump_name = get_or_compute(pc_config, inst)\n", + "\n", + "with np.load(dump_name) as data:\n", + " lat_comp = data['lat_comp']\n", + " lat_mean = data['lat_mean']\n", + "\n", + "# SG-ffhq-w, non-conditional\n", + "d_ffhq_pose = np.load('data/interfacegan/stylegan_ffhq_pose_w_boundary.npy').astype(np.float32)\n", + "d_ffhq_smile = np.load('data/interfacegan/stylegan_ffhq_smile_w_boundary.npy').astype(np.float32)\n", + "d_ffhq_gender = np.load('data/interfacegan/stylegan_ffhq_gender_w_boundary.npy').astype(np.float32)\n", + "d_ffhq_glasses = np.load('data/interfacegan/stylegan_ffhq_eyeglasses_w_boundary.npy').astype(np.float32)\n", + "\n", + "# Indices determined by visual inspection\n", + "d_ours_pose = lat_comp[9]\n", + "d_ours_smile = lat_comp[44]\n", + "d_ours_gender = lat_comp[0]\n", + "d_ours_glasses = lat_comp[12]\n", + "\n", + "model.truncation = 1.0 # NOT IMPLEMENTED\n", + "compute(model, lat_mean, 'pose', 'ffhq', [440608316, 1811098088, 129888612], d_ours_pose, 0, 7, -1.0, d_ffhq_pose, 1.0)\n", + "compute(model, lat_mean, 'smile', 'ffhq', [1759734403, 1647189561, 70163682], d_ours_smile, 3, 4, -8.5, d_ffhq_smile, 1.0)\n", + "compute(model, lat_mean, 'gender', 'ffhq', [1302836080, 1746672325], d_ours_gender, 2, 6, -4.5, d_ffhq_gender, 1.5)\n", + "compute(model, lat_mean, 'glasses', 'ffhq', [1565213752, 1005764659, 1110182583], d_ours_glasses, 0, 2, 4.0, d_ffhq_glasses, 1.0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# StyleGAN1-ffhq (Steerability)\n", + "\n", + "inst = get_instrumented_model('StyleGAN', 'ffhq', 'g_mapping', device, use_w=True, inst=inst)\n", + "model = inst.model\n", + "\n", + "K = model.get_max_latents()\n", + "pc_config = Config(components=128, n=1_000_000, use_w=True,\n", + " layer='g_mapping', model='StyleGAN', output_class='ffhq')\n", + "dump_name = get_or_compute(pc_config, inst)\n", + "\n", + "with np.load(dump_name) as data:\n", + " lat_comp = data['lat_comp']\n", + " lat_mean = data['lat_mean']\n", + "\n", + "# SG-ffhq-w, non-conditional\n", + "# Shapes: [18, 512]\n", + "d_ffhq_R = np.load('data/steerability/stylegan_ffhq/ffhq_rgb_0.npy').astype(np.float32)\n", + "d_ffhq_G = np.load('data/steerability/stylegan_ffhq/ffhq_rgb_1.npy').astype(np.float32)\n", + "d_ffhq_B = np.load('data/steerability/stylegan_ffhq/ffhq_rgb_2.npy').astype(np.float32)\n", + "\n", + "# Indices determined by visual inspection\n", + "d_ours_R = lat_comp[0]\n", + "d_ours_G = -lat_comp[1]\n", + "d_ours_B = -lat_comp[2]\n", + "\n", + "model.truncation = 1.0 # NOT IMPLEMENTED\n", + "compute(model, lat_mean, 'red', 'ffhq', [5], d_ours_R, 17, 18, 8.0, d_ffhq_R, 1.0, center=False)\n", + "compute(model, lat_mean, 'green', 'ffhq', [5], d_ours_G, 17, 18, 15.0, d_ffhq_G, 1.0, center=False)\n", + "compute(model, lat_mean, 'blue', 'ffhq', [5], d_ours_B, 17, 18, 10.0, d_ffhq_B, 1.0, center=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [], + "source": [ + "# StyleGAN1-celebahq (InterfaceGAN)\n", + "\n", + "inst = get_instrumented_model('StyleGAN', 'celebahq', 'g_mapping', device, use_w=True, inst=inst)\n", + "model = inst.model\n", + "\n", + "K = model.get_max_latents()\n", + "pc_config = Config(components=128, n=1_000_000, use_w=True,\n", + " layer='g_mapping', model='StyleGAN', output_class='celebahq')\n", + "dump_name = get_or_compute(pc_config, inst)\n", + "\n", + "with np.load(dump_name) as data:\n", + " lat_comp = data['lat_comp']\n", + " lat_mean = data['lat_mean']\n", + "\n", + "# SG-ffhq-w, non-conditional\n", + "d_celebahq_pose = np.load('data/interfacegan/stylegan_celebahq_pose_w_boundary.npy').astype(np.float32)\n", + "d_celebahq_smile = np.load('data/interfacegan/stylegan_celebahq_smile_w_boundary.npy').astype(np.float32)\n", + "d_celebahq_gender = np.load('data/interfacegan/stylegan_celebahq_gender_w_boundary.npy').astype(np.float32)\n", + "d_celebahq_glasses = np.load('data/interfacegan/stylegan_celebahq_eyeglasses_w_boundary.npy').astype(np.float32)\n", + "\n", + "# Indices determined by visual inspection\n", + "d_ours_pose = lat_comp[7]\n", + "d_ours_smile = lat_comp[14]\n", + "d_ours_gender = lat_comp[1]\n", + "d_ours_glasses = lat_comp[5]\n", + "\n", + "model.truncation = 1.0 # NOT IMPLEMENTED\n", + "compute(model, lat_mean, 'pose', 'celebahq', [1939067252, 1460055449, 329555154], d_ours_pose, 0, 7, -1.0, d_celebahq_pose, 1.0)\n", + "compute(model, lat_mean, 'smile', 'celebahq', [329187806, 424805522, 1777796971], d_ours_smile, 3, 4, -7.0, d_celebahq_smile, 1.3)\n", + "compute(model, lat_mean, 'gender', 'celebahq', [1144615644, 967075839, 264878205], d_ours_gender, 0, 2, -3.2, d_celebahq_gender, 1.2)\n", + "compute(model, lat_mean, 'glasses', 'celebahq', [991993380, 594344173, 2119328990, 1919124025], d_ours_glasses, 0, 1, -10.0, d_celebahq_glasses, 2.0) # hard for both" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false, + "tags": [] + }, + "outputs": [], + "source": [ + "# StyleGAN1-cars (Steerability)\n", + "\n", + "inst = get_instrumented_model('StyleGAN', 'cars', 'g_mapping', device, use_w=True, inst=inst)\n", + "model = inst.model\n", + "\n", + "K = model.get_max_latents()\n", + "pc_config = Config(components=128, n=1_000_000, use_w=True,\n", + " layer='g_mapping', model='StyleGAN', output_class='cars')\n", + "dump_name = get_or_compute(pc_config, inst)\n", + "\n", + "with np.load(dump_name) as data:\n", + " lat_comp = data['lat_comp']\n", + " lat_mean = data['lat_mean']\n", + "\n", + "# Shapes: [16, 512]\n", + "d_cars_rot = np.load('data/steerability/stylegan_cars/rotate2d.npy').astype(np.float32)\n", + "d_cars_shift = np.load('data/steerability/stylegan_cars/shifty.npy').astype(np.float32)\n", + "\n", + "# Add two final layers\n", + "d_cars_rot = np.append(d_cars_rot, np.zeros((2,512), dtype=np.float32), axis=0)\n", + "d_cars_shift = np.append(d_cars_shift, np.zeros((2,512), dtype=np.float32), axis=0)\n", + "\n", + "print(d_cars_rot.shape)\n", + "\n", + "# Indices determined by visual inspection\n", + "d_ours_rot = lat_comp[0]\n", + "d_ours_shift = lat_comp[7]\n", + "\n", + "model.truncation = 1.0 # NOT IMPLEMENTED\n", + "compute(model, lat_mean, 'rotate2d', 'cars', [46, 28], d_ours_rot, 0, 1, 1.0, d_cars_rot, 1.0, center=False)\n", + "compute(model, lat_mean, 'shifty', 'cars', [0, 13], d_ours_shift, 1, 2, 4.0, d_cars_shift, 1.0, center=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "file_extension": ".py", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.7-final" + }, + "mimetype": "text/x-python", + "name": "python", + "npconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": 3 + }, + "nbformat": 4, + "nbformat_minor": 2 +} \ No newline at end of file diff --git a/notebooks/figure_teaser.ipynb b/notebooks/figure_teaser.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..5cdee7375615910174b21c82f77db614b197b0b5 --- /dev/null +++ b/notebooks/figure_teaser.ipynb @@ -0,0 +1,260 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Copyright 2020 Erik Härkönen. All rights reserved.\n", + "# This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n", + "# you may not use this file except in compliance with the License. You may obtain a copy\n", + "# of the License at http://www.apache.org/licenses/LICENSE-2.0\n", + "\n", + "# Unless required by applicable law or agreed to in writing, software distributed under\n", + "# the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n", + "# OF ANY KIND, either express or implied. See the License for the specific language\n", + "# governing permissions and limitations under the License.\n", + "\n", + "# Teaser: sequence of 3 interesting edits\n", + "%matplotlib inline\n", + "from notebook_init import *\n", + "\n", + "rand = lambda : np.random.randint(np.iinfo(np.int32).max)\n", + "outdir = Path('out/figures/teaser')\n", + "makedirs(outdir, exist_ok=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def setup_model(model_name, class_name, layer_name):\n", + " global inst, model, lat_comp, lat_mean, lat_std\n", + "\n", + " use_w = 'StyleGAN' in model_name\n", + " inst = get_instrumented_model(model_name, class_name, layer_name, device, use_w=use_w, inst=inst)\n", + " model = inst.model\n", + "\n", + " pc_config = Config(components=80, n=1_000_000, batch_size=200,\n", + " layer=layer_name, model=model_name, output_class=class_name, use_w=use_w)\n", + " dump_name = get_or_compute(pc_config, inst)\n", + "\n", + " with np.load(dump_name) as data:\n", + " lat_comp = data['lat_comp']\n", + " lat_mean = data['lat_mean']\n", + " lat_std = data['lat_stdev']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def perform_edit(seeds, edit_sequence, save_images=False, crop=None):\n", + " max_figs = 1000 if save_images else 10\n", + "\n", + " for seed in seeds[:max_figs]:\n", + " w = model.sample_latent(1, seed=seed).cpu().numpy()\n", + " w = [w]*model.get_max_latents()\n", + " imgs = []\n", + " \n", + " # Starting point\n", + " imgs.append(model.sample_np(w))\n", + " \n", + " # Perform edits in order\n", + " for edit in edit_sequence:\n", + " (idx, start, end, strength, invert) = configs[edit]\n", + " \n", + " # Find out coordinate of w along PC\n", + " w_centered = w[0] - lat_mean\n", + " w_coord = np.sum(w_centered.reshape(-1)*lat_comp[idx].reshape(-1)) / lat_std[idx]\n", + " \n", + " # Invert property if desired (e.g. flip rotation)\n", + " # Otherwise reinforce existing\n", + " if invert:\n", + " sign = w_coord / np.abs(w_coord)\n", + " target = -sign*strength # opposite side of mean\n", + " else:\n", + " target = strength\n", + " \n", + " delta = target - w_coord # offset vector\n", + " \n", + " for l in range(start, end):\n", + " w[l] = w[l] + lat_comp[idx]*lat_std[idx]*delta\n", + " imgs.append(model.sample_np(w))\n", + " \n", + " # Crop away black borders\n", + " if crop:\n", + " imgs = [img[crop[0]:-crop[1], crop[2]:-crop[3], :] for img in imgs]\n", + "\n", + " if save_images:\n", + " # Save to disk\n", + " for i, img in enumerate(imgs):\n", + " Image.fromarray((img*255).astype(np.uint8)).save(outdir / f'teaser_{seed}_{i}.png')\n", + " \n", + " # Show in notebook\n", + " strip = np.hstack(imgs)\n", + " #strip = strip[::2, ::2, :] # 2x downscale for preview\n", + " plt.figure(figsize=(30,5))\n", + " plt.imshow(strip, interpolation='bilinear')\n", + " plt.axis('off')\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# (idx, edit_start, edit_end, strength, invert)\n", + "configs = {\n", + " # StyleGAN2 cars W\n", + " 'Redness': (22, 9, 11, -8, False),\n", + " 'Horizontal flip': ( 0, 0, 5, 2.0, True),\n", + " 'Add grass': (41, 9, 11, -18, False),\n", + " 'Blocky shape': (16, 3, 6, 25, False),\n", + "\n", + " # BigGAN-512 irish_setter\n", + " 'Move right': ( 0, 0, 15, -1.5, False),\n", + " 'Rotate': ( 3, 0, 15, -0.5, False),\n", + " 'Move back': ( 4, 0, 15, 2.5, False),\n", + " 'Zoom in': ( 6, 0, 15, -2.0, False),\n", + " 'Zoom out': (12, 0, 15, -4.0, False),\n", + " 'Sharpen BG': (13, 6, 9, 20.0, False),\n", + " 'Camera down': (15, 1, 6, -4.0, False),\n", + " 'Light right': (28, 7, 8, 30, False),\n", + " 'Pixelate': (46, 10, 11, -25, False),\n", + " 'Reeds': (61, 4, 8, -15, False),\n", + " 'Dry BG': (65, 6, 8, -30, False),\n", + " 'Grass length': (69, 5, 8, 15, False),\n", + "\n", + " # StyleGAN2 ffhq\n", + " 'frizzy_hair': (31, 2, 6, 20, False),\n", + " 'background_blur': (49, 6, 9, 20, False),\n", + " 'bald': (21, 2, 5, 20, False),\n", + " 'big_smile': (19, 4, 5, 20, False),\n", + " 'caricature_smile': (26, 3, 8, 13, False),\n", + " 'scary_eyes': (33, 6, 8, 20, False),\n", + " 'curly_hair': (47, 3, 6, 20, False),\n", + " 'dark_bg_shiny_hair': (13, 8, 9, 20, False),\n", + " 'dark_hair_and_light_pos': (14, 8, 9, 20, False),\n", + " 'dark_hair': (16, 8, 9, 20, False),\n", + " 'disgusted': (43, 6, 8, -30, False),\n", + " 'displeased': (36, 4, 7, 20, False),\n", + " 'eye_openness': (54, 7, 8, 20, False),\n", + " 'eye_wrinkles': (28, 6, 8, 20, False),\n", + " 'eyebrow_thickness': (37, 8, 9, 20, False),\n", + " 'face_roundness': (37, 0, 5, 20, False),\n", + " 'fearful_eyes': (54, 4, 10, 20, False),\n", + " 'hairline': (21, 4, 5, -20, False),\n", + " 'happy_frizzy_hair': (30, 0, 8, 20, False),\n", + " 'happy_elderly_lady': (27, 4, 7, 20, False),\n", + " 'head_angle_up': (11, 1, 4, 20, False),\n", + " 'huge_grin': (28, 4, 6, 20, False),\n", + " 'in_awe': (23, 3, 6, -15, False),\n", + " 'wide_smile': (23, 3, 6, 20, False),\n", + " 'large_jaw': (22, 3, 6, 20, False),\n", + " 'light_lr': (15, 8, 9, 10, False),\n", + " 'lipstick_and_age': (34, 6, 11, 20, False),\n", + " 'lipstick': (34, 10, 11, 20, False),\n", + " 'mascara_vs_beard': (41, 6, 9, 20, False),\n", + " 'nose_length': (51, 4, 5, -20, False),\n", + " 'elderly_woman': (34, 6, 7, 20, False),\n", + " 'overexposed': (27, 8, 18, 15, False),\n", + " 'screaming': (35, 3, 7, -15, False),\n", + " 'short_face': (32, 2, 6, -20, False),\n", + " 'show_front_teeth': (59, 4, 5, 40, False),\n", + " 'smile': (46, 4, 5, -20, False),\n", + " 'straight_bowl_cut': (20, 4, 5, -20, False),\n", + " 'sunlight_in_face': (10, 8, 9, 10, False),\n", + " 'trimmed_beard': (58, 7, 9, 20, False),\n", + " 'white_hair': (57, 7, 10, -24, False),\n", + " 'wrinkles': (20, 6, 7, -18, False),\n", + " 'boyishness': (8, 2, 5, 20, False),\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# StyleGAN2 faces - emphasis on novel edits\n", + "setup_model('StyleGAN2', 'ffhq', 'style')\n", + "model.truncation = 0.7\n", + "model.use_w()\n", + "\n", + "seeds = [6293435, 2105448342] # + [rand() for _ in range(1)]\n", + "print(seeds)\n", + "edits = ['wrinkles', 'white_hair', 'in_awe', 'overexposed']\n", + "perform_edit(seeds, edits, True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# StyleGAN2 cars\n", + "setup_model('StyleGAN2', 'car', 'style')\n", + "model.truncation = 0.6\n", + "model.use_w()\n", + "\n", + "seeds = [440749230] # + [rand() for _ in range(10)]\n", + "edits = ['Redness', 'Horizontal flip', 'Add grass', 'Blocky shape']\n", + "perform_edit(seeds, edits, True, crop=[64, 64, 1, 1])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# BigGAN-512 irish setter\n", + "setup_model('BigGAN-512', 'husky', 'generator.gen_z')\n", + "model.set_output_class('irish_setter')\n", + "model.truncation = 0.6\n", + "\n", + "seeds = [489408325]# + [rand() for _ in range(10)]\n", + "edits = ['Rotate', 'Zoom out', 'Camera down', 'Reeds']\n", + "perform_edit(seeds, edits, True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/notebook_init.py b/notebooks/notebook_init.py new file mode 100644 index 0000000000000000000000000000000000000000..4640339c1b92478a1c9e44d4e69e40364b0f6807 --- /dev/null +++ b/notebooks/notebook_init.py @@ -0,0 +1,35 @@ +# Copyright 2020 Erik Härkönen. All rights reserved. +# This file is licensed to you under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. You may obtain a copy +# of the License at http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software distributed under +# the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS +# OF ANY KIND, either express or implied. See the License for the specific language +# governing permissions and limitations under the License. + +# Shared init code for noteoboks +# Usage: from notebook_init import * + +import torch +import numpy as np +from os import makedirs +from types import SimpleNamespace +import matplotlib.pyplot as plt +from pathlib import Path +from PIL import Image +import pickle + +import sys +sys.path.insert(0, '..') +from models import get_instrumented_model, get_model +from notebook_utils import create_strip, create_strip_centered, prettify_name, save_frames, pad_frames +from config import Config +from decomposition import get_or_compute + +torch.autograd.set_grad_enabled(False) +torch.backends.cudnn.benchmark = True + +has_gpu = torch.cuda.is_available() +device = torch.device('cuda' if has_gpu else 'cpu') +inst = None \ No newline at end of file diff --git a/notebooks/notebook_utils.py b/notebooks/notebook_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..5f421c441199fa04037adf739fd911df6f1c1559 --- /dev/null +++ b/notebooks/notebook_utils.py @@ -0,0 +1,200 @@ +# Copyright 2020 Erik Härkönen. All rights reserved. +# This file is licensed to you under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. You may obtain a copy +# of the License at http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software distributed under +# the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS +# OF ANY KIND, either express or implied. See the License for the specific language +# governing permissions and limitations under the License. + +import torch +import numpy as np +from os import makedirs +from PIL import Image + +import sys +from pathlib import Path +sys.path.insert(0, str(Path(__file__).parent.parent)) +from utils import prettify_name, pad_frames + +# Apply edit to given latents, return strip of images +def create_strip(inst, mode, layer, latents, x_comp, z_comp, act_stdev, lat_stdev, sigma, layer_start, layer_end, num_frames=5): + return _create_strip_impl(inst, mode, layer, latents, x_comp, z_comp, act_stdev, + lat_stdev, None, None, sigma, layer_start, layer_end, num_frames, center=False) + +# Strip where the sample is centered along the component before manipulation +def create_strip_centered(inst, mode, layer, latents, x_comp, z_comp, act_stdev, lat_stdev, act_mean, lat_mean, sigma, layer_start, layer_end, num_frames=5): + return _create_strip_impl(inst, mode, layer, latents, x_comp, z_comp, act_stdev, + lat_stdev, act_mean, lat_mean, sigma, layer_start, layer_end, num_frames, center=True) + +def _create_strip_impl(inst, mode, layer, latents, x_comp, z_comp, act_stdev, lat_stdev, act_mean, lat_mean, sigma, layer_start, layer_end, num_frames, center): + if not isinstance(latents, list): + latents = list(latents) + + max_lat = inst.model.get_max_latents() + if layer_end < 0 or layer_end > max_lat: + layer_end = max_lat + layer_start = np.clip(layer_start, 0, layer_end) + + if len(latents) > num_frames: + # Batch over latents + return _create_strip_batch_lat(inst, mode, layer, latents, x_comp, z_comp, + act_stdev, lat_stdev, act_mean, lat_mean, sigma, layer_start, layer_end, num_frames, center) + else: + # Batch over strip frames + return _create_strip_batch_sigma(inst, mode, layer, latents, x_comp, z_comp, + act_stdev, lat_stdev, act_mean, lat_mean, sigma, layer_start, layer_end, num_frames, center) + +# Batch over frames if there are more frames in strip than latents +def _create_strip_batch_sigma(inst, mode, layer, latents, x_comp, z_comp, act_stdev, lat_stdev, act_mean, lat_mean, sigma, layer_start, layer_end, num_frames, center): + inst.close() + batch_frames = [[] for _ in range(len(latents))] + + B = min(num_frames, 5) + lep_padded = ((num_frames - 1) // B + 1) * B + sigma_range = np.linspace(-sigma, sigma, num_frames) + sigma_range = np.concatenate([sigma_range, np.zeros((lep_padded - num_frames))]) + sigma_range = torch.from_numpy(sigma_range).float().to(inst.model.device) + normalize = lambda v : v / torch.sqrt(torch.sum(v**2, dim=-1, keepdim=True) + 1e-8) + + for i_batch in range(lep_padded // B): + sigmas = sigma_range[i_batch*B:(i_batch+1)*B] + + for i_lat in range(len(latents)): + z_single = latents[i_lat] + z_batch = z_single.repeat_interleave(B, axis=0) + + zeroing_offset_act = 0 + zeroing_offset_lat = 0 + if center: + if mode == 'activation': + # Center along activation before applying offset + inst.retain_layer(layer) + _ = inst.model.sample_np(z_single) + value = inst.retained_features()[layer].clone() + dotp = torch.sum((value - act_mean)*normalize(x_comp), dim=-1, keepdim=True) + zeroing_offset_act = normalize(x_comp)*dotp # offset that sets coordinate to zero + else: + # Shift latent to lie on mean along given component + dotp = torch.sum((z_single - lat_mean)*normalize(z_comp), dim=-1, keepdim=True) + zeroing_offset_lat = dotp*normalize(z_comp) + + with torch.no_grad(): + z = z_batch + + if mode in ['latent', 'both']: + z = [z]*inst.model.get_max_latents() + delta = z_comp * sigmas.reshape([-1] + [1]*(z_comp.ndim - 1)) * lat_stdev + for i in range(layer_start, layer_end): + z[i] = z[i] - zeroing_offset_lat + delta + + if mode in ['activation', 'both']: + comp_batch = x_comp.repeat_interleave(B, axis=0) + delta = comp_batch * sigmas.reshape([-1] + [1]*(comp_batch.ndim - 1)) + inst.edit_layer(layer, offset=delta * act_stdev - zeroing_offset_act) + + img_batch = inst.model.sample_np(z) + if img_batch.ndim == 3: + img_batch = np.expand_dims(img_batch, axis=0) + + for j, img in enumerate(img_batch): + idx = i_batch*B + j + if idx < num_frames: + batch_frames[i_lat].append(img) + + return batch_frames + +# Batch over latents if there are more latents than frames in strip +def _create_strip_batch_lat(inst, mode, layer, latents, x_comp, z_comp, act_stdev, lat_stdev, act_mean, lat_mean, sigma, layer_start, layer_end, num_frames, center): + n_lat = len(latents) + B = min(n_lat, 5) + + max_lat = inst.model.get_max_latents() + if layer_end < 0 or layer_end > max_lat: + layer_end = max_lat + layer_start = np.clip(layer_start, 0, layer_end) + + len_padded = ((n_lat - 1) // B + 1) * B + batch_frames = [[] for _ in range(n_lat)] + + for i_batch in range(len_padded // B): + zs = latents[i_batch*B:(i_batch+1)*B] + if len(zs) == 0: + continue + + z_batch_single = torch.cat(zs, 0) + + inst.close() # don't retain, remove edits + sigma_range = np.linspace(-sigma, sigma, num_frames, dtype=np.float32) + + normalize = lambda v : v / torch.sqrt(torch.sum(v**2, dim=-1, keepdim=True) + 1e-8) + + zeroing_offset_act = 0 + zeroing_offset_lat = 0 + if center: + if mode == 'activation': + # Center along activation before applying offset + inst.retain_layer(layer) + _ = inst.model.sample_np(z_batch_single) + value = inst.retained_features()[layer].clone() + dotp = torch.sum((value - act_mean)*normalize(x_comp), dim=-1, keepdim=True) + zeroing_offset_act = normalize(x_comp)*dotp # offset that sets coordinate to zero + else: + # Shift latent to lie on mean along given component + dotp = torch.sum((z_batch_single - lat_mean)*normalize(z_comp), dim=-1, keepdim=True) + zeroing_offset_lat = dotp*normalize(z_comp) + + for i in range(len(sigma_range)): + s = sigma_range[i] + + with torch.no_grad(): + z = [z_batch_single]*inst.model.get_max_latents() # one per layer + + if mode in ['latent', 'both']: + delta = z_comp*s*lat_stdev + for i in range(layer_start, layer_end): + z[i] = z[i] - zeroing_offset_lat + delta + + if mode in ['activation', 'both']: + act_delta = x_comp*s*act_stdev + inst.edit_layer(layer, offset=act_delta - zeroing_offset_act) + + img_batch = inst.model.sample_np(z) + if img_batch.ndim == 3: + img_batch = np.expand_dims(img_batch, axis=0) + + for j, img in enumerate(img_batch): + img_idx = i_batch*B + j + if img_idx < n_lat: + batch_frames[img_idx].append(img) + + return batch_frames + + +def save_frames(title, model_name, rootdir, frames, strip_width=10): + test_name = prettify_name(title) + outdir = f'{rootdir}/{model_name}/{test_name}' + makedirs(outdir, exist_ok=True) + + # Limit maximum resolution + max_H = 512 + real_H = frames[0][0].shape[0] + ratio = min(1.0, max_H / real_H) + + # Combined with first 10 + strips = [np.hstack(frames) for frames in frames[:strip_width]] + if len(strips) >= strip_width: + left_col = np.vstack(strips[0:strip_width//2]) + right_col = np.vstack(strips[5:10]) + grid = np.hstack([left_col, np.ones_like(left_col[:, :30]), right_col]) + im = Image.fromarray((255*grid).astype(np.uint8)) + im = im.resize((int(ratio*im.size[0]), int(ratio*im.size[1])), Image.ANTIALIAS) + im.save(f'{outdir}/{test_name}_all.png') + else: + print('Too few strips to create grid, creating just strips!') + + for ex_num, strip in enumerate(frames[:strip_width]): + im = Image.fromarray(np.uint8(255*np.hstack(pad_frames(strip)))) + im = im.resize((int(ratio*im.size[0]), int(ratio*im.size[1])), Image.ANTIALIAS) + im.save(f'{outdir}/{test_name}_{ex_num}.png') \ No newline at end of file diff --git a/out/directions/StyleGAN2-Light_direction-ffhq-ipca-w-style-comp15-range8-9.pkl b/out/directions/StyleGAN2-Light_direction-ffhq-ipca-w-style-comp15-range8-9.pkl new file mode 100644 index 0000000000000000000000000000000000000000..bcdbc8214010746f3ae42e3d25fe095349f111bf --- /dev/null +++ b/out/directions/StyleGAN2-Light_direction-ffhq-ipca-w-style-comp15-range8-9.pkl @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:99450cc854cdc71102dd1dac7a075250d450a01405d86afe2aa985e24d387e57 +size 4904 diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..92dee5175f9ffee5fe6026b53b035d27a0bf0317 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,15 @@ +python +torch==1.3 +torchvision +cudatoolkit==10.1 +pillow==6.2 +ffmpeg +tqdm +scipy +scikit-learn +scikit-image +boto3 +requests +nltk +fbpca +pyopengltk diff --git a/simple_tokenizer.py b/simple_tokenizer.py new file mode 100644 index 0000000000000000000000000000000000000000..0a66286b7d5019c6e221932a813768038f839c91 --- /dev/null +++ b/simple_tokenizer.py @@ -0,0 +1,132 @@ +import gzip +import html +import os +from functools import lru_cache + +import ftfy +import regex as re + + +@lru_cache() +def default_bpe(): + return os.path.join(os.path.dirname(os.path.abspath(__file__)), "bpe_simple_vocab_16e6.txt.gz") + + +@lru_cache() +def bytes_to_unicode(): + """ + Returns list of utf-8 byte and a corresponding list of unicode strings. + The reversible bpe codes work on unicode strings. + This means you need a large # of unicode characters in your vocab if you want to avoid UNKs. + When you're at something like a 10B token dataset you end up needing around 5K for decent coverage. + This is a signficant percentage of your normal, say, 32K bpe vocab. + To avoid that, we want lookup tables between utf-8 bytes and unicode strings. + And avoids mapping to whitespace/control characters the bpe code barfs on. + """ + bs = list(range(ord("!"), ord("~")+1))+list(range(ord("¡"), ord("¬")+1))+list(range(ord("®"), ord("ÿ")+1)) + cs = bs[:] + n = 0 + for b in range(2**8): + if b not in bs: + bs.append(b) + cs.append(2**8+n) + n += 1 + cs = [chr(n) for n in cs] + return dict(zip(bs, cs)) + + +def get_pairs(word): + """Return set of symbol pairs in a word. + Word is represented as tuple of symbols (symbols being variable-length strings). + """ + pairs = set() + prev_char = word[0] + for char in word[1:]: + pairs.add((prev_char, char)) + prev_char = char + return pairs + + +def basic_clean(text): + text = ftfy.fix_text(text) + text = html.unescape(html.unescape(text)) + return text.strip() + + +def whitespace_clean(text): + text = re.sub(r'\s+', ' ', text) + text = text.strip() + return text + + +class SimpleTokenizer(object): + def __init__(self, bpe_path: str = default_bpe()): + self.byte_encoder = bytes_to_unicode() + self.byte_decoder = {v: k for k, v in self.byte_encoder.items()} + merges = gzip.open(bpe_path).read().decode("utf-8").split('\n') + merges = merges[1:49152-256-2+1] + merges = [tuple(merge.split()) for merge in merges] + vocab = list(bytes_to_unicode().values()) + vocab = vocab + [v+'' for v in vocab] + for merge in merges: + vocab.append(''.join(merge)) + vocab.extend(['<|startoftext|>', '<|endoftext|>']) + self.encoder = dict(zip(vocab, range(len(vocab)))) + self.decoder = {v: k for k, v in self.encoder.items()} + self.bpe_ranks = dict(zip(merges, range(len(merges)))) + self.cache = {'<|startoftext|>': '<|startoftext|>', '<|endoftext|>': '<|endoftext|>'} + self.pat = re.compile(r"""<\|startoftext\|>|<\|endoftext\|>|'s|'t|'re|'ve|'m|'ll|'d|[\p{L}]+|[\p{N}]|[^\s\p{L}\p{N}]+""", re.IGNORECASE) + + def bpe(self, token): + if token in self.cache: + return self.cache[token] + word = tuple(token[:-1]) + ( token[-1] + '',) + pairs = get_pairs(word) + + if not pairs: + return token+'' + + while True: + bigram = min(pairs, key = lambda pair: self.bpe_ranks.get(pair, float('inf'))) + if bigram not in self.bpe_ranks: + break + first, second = bigram + new_word = [] + i = 0 + while i < len(word): + try: + j = word.index(first, i) + new_word.extend(word[i:j]) + i = j + except: + new_word.extend(word[i:]) + break + + if word[i] == first and i < len(word)-1 and word[i+1] == second: + new_word.append(first+second) + i += 2 + else: + new_word.append(word[i]) + i += 1 + new_word = tuple(new_word) + word = new_word + if len(word) == 1: + break + else: + pairs = get_pairs(word) + word = ' '.join(word) + self.cache[token] = word + return word + + def encode(self, text): + bpe_tokens = [] + text = whitespace_clean(basic_clean(text)).lower() + for token in re.findall(self.pat, text): + token = ''.join(self.byte_encoder[b] for b in token.encode('utf-8')) + bpe_tokens.extend(self.encoder[bpe_token] for bpe_token in self.bpe(token).split(' ')) + return bpe_tokens + + def decode(self, tokens): + text = ''.join([self.decoder[token] for token in tokens]) + text = bytearray([self.byte_decoder[c] for c in text]).decode('utf-8', errors="replace").replace('', ' ') + return text diff --git a/tests/layerwise_z_test.py b/tests/layerwise_z_test.py new file mode 100644 index 0000000000000000000000000000000000000000..80d62982e6f1cef5209936b755407a0ab542a0e9 --- /dev/null +++ b/tests/layerwise_z_test.py @@ -0,0 +1,75 @@ +# Copyright 2020 Erik Härkönen. All rights reserved. +# This file is licensed to you under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. You may obtain a copy +# of the License at http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software distributed under +# the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS +# OF ANY KIND, either express or implied. See the License for the specific language +# governing permissions and limitations under the License. + +import torch, numpy as np +from types import SimpleNamespace +import itertools + +import sys +from pathlib import Path +sys.path.insert(0, str(Path(__file__).parent.parent)) +from models import get_model +from config import Config + +torch.backends.cudnn.benchmark = True +has_gpu = torch.cuda.is_available() +device = torch.device('cuda' if has_gpu else 'cpu') +B = 2 # test batch support + +models = [ + ('BigGAN-128', 'husky'), + ('BigGAN-256', 'husky'), + ('BigGAN-512', 'husky'), + ('StyleGAN', 'ffhq'), + ('StyleGAN2', 'ffhq'), +] + +for model_name, classname in models: + with torch.no_grad(): + model = get_model(model_name, classname, device).to(device) + print(f'Testing {model_name}-{classname}', end='') + + n_latents = model.get_max_latents() + assert n_latents > 1, 'Model reports max_latents=1' + + #if hasattr(model, 'use_w'): + # model.use_w() + + seed = 1234 + torch.manual_seed(seed) + np.random.seed(seed) + latents = [model.sample_latent(B, seed=seed) for _ in range(10)] + + # Test that partial-forward supports layerwise latent inputs + try: + layer_name, _ = list(model.named_modules())[-1] + _ = model.partial_forward(n_latents*[latents[0]], layer_name) + except Exception as e: + print('Error:', e) + raise RuntimeError(f"{model_name} partial forward doesn't support layerwise latent!") + + # Test that layerwise and single give same result + for z in latents: + torch.manual_seed(0) + np.random.seed(0) + out1 = model.forward(z) + + torch.manual_seed(0) + np.random.seed(0) + out2 = model.forward(n_latents*[z]) + + dist_rel = (torch.abs(out1 - out2).sum() / out1.sum()).item() + assert dist_rel < 1e-3, f'Layerwise latent mode working incorrectly for model {model_name}-{classname}: difference = {dist_rel*100}%' + + print('.', end='') + + print('OK!') + + diff --git a/tests/partial_forward_test.py b/tests/partial_forward_test.py new file mode 100644 index 0000000000000000000000000000000000000000..8896eb5ac04bedafea81fde1de98d5778cc8846b --- /dev/null +++ b/tests/partial_forward_test.py @@ -0,0 +1,124 @@ +# Copyright 2020 Erik Härkönen. All rights reserved. +# This file is licensed to you under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. You may obtain a copy +# of the License at http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software distributed under +# the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS +# OF ANY KIND, either express or implied. See the License for the specific language +# governing permissions and limitations under the License. + +import torch, numpy as np +from types import SimpleNamespace +import itertools + +import sys +from pathlib import Path +sys.path.insert(0, str(Path(__file__).parent.parent)) +from models import get_instrumented_model + + +SEED = 1369 +SAMPLES = 100 +B = 10 + +torch.backends.cudnn.benchmark = True +has_gpu = torch.cuda.is_available() +device = torch.device('cuda' if has_gpu else 'cpu') + + +def compare(model, layer, z1, z2): + # Run partial forward + torch.manual_seed(0) + np.random.seed(0) + inst._retained[layer] = None + with torch.no_grad(): + model.partial_forward(z1, layer) + + assert inst._retained[layer] is not None, 'Layer not retained (partial)' + feat_partial = inst._retained[layer].cpu().numpy().copy().reshape(-1) + + # Run standard forward + torch.manual_seed(0) + np.random.seed(0) + inst._retained[layer] = None + with torch.no_grad(): + model.forward(z2) + + assert inst._retained[layer] is not None, 'Layer not retained (full)' + feat_full = inst.retained_features()[layer].cpu().numpy().copy().reshape(-1) + + diff = np.sum(np.abs(feat_partial - feat_full)) + return diff + + +configs = [] + +# StyleGAN2 +models = ['StyleGAN2'] +layers = ['convs.0',] +classes = ['cat', 'ffhq'] +configs.append(itertools.product(models, layers, classes)) + +# StyleGAN +models = ['StyleGAN'] +layers = [ + 'g_synthesis.blocks.128x128.conv0_up', + 'g_synthesis.blocks.128x128.conv0_up.upscale', + 'g_synthesis.blocks.256x256.conv0_up', + 'g_synthesis.blocks.1024x1024.epi2.style_mod.lin' +] +classes = ['ffhq'] +configs.append(itertools.product(models, layers, classes)) + +# ProGAN +models = ['ProGAN'] +layers = ['layer2', 'layer7'] +classes = ['churchoutdoor', 'bedroom'] +configs.append(itertools.product(models, layers, classes)) + +# BigGAN +models = ['BigGAN-512', 'BigGAN-256', 'BigGAN-128'] +layers = ['generator.layers.2.conv_1', 'generator.layers.5.relu', 'generator.layers.10.bn_2'] +classes = ['husky'] +configs.append(itertools.product(models, layers, classes)) + +# Run all configurations +for config in configs: + for model_name, layer, outclass in config: + print('Testing', model_name, layer, outclass) + inst = get_instrumented_model(model_name, outclass, layer, device) + model = inst.model + + # Test negative + z_dummy = model.sample_latent(B) + z1 = torch.zeros_like(z_dummy).to(device) + z2 = torch.ones_like(z_dummy).to(device) + diff = compare(model, layer, z1, z2) + assert diff > 1e-8, 'Partial and full should differ, but they do not!' + + # Test model randomness (should be seeded away) + z1 = model.sample_latent(1) + inst._retained[layer] = None + with torch.no_grad(): + model.forward(z1) + feat1 = inst._retained[layer].reshape(-1) + model.forward(z1) + feat2 = inst._retained[layer].reshape(-1) + diff = torch.sum(torch.abs(feat1 - feat2)) + assert diff < 1e-8, f'Layer {layer} output contains randomness, diff={diff}' + + + # Test positive + torch.manual_seed(SEED) + np.random.seed(SEED) + latents = model.sample_latent(SAMPLES, seed=SEED) + + for i in range(0, SAMPLES, B): + print(f'Layer {layer}: {i}/{SAMPLES}', end='\r') + z = latents[i:i+B] + diff = compare(model, layer, z, z) + assert diff < 1e-8, f'Partial and full forward differ by {diff}' + + del model + torch.cuda.empty_cache() \ No newline at end of file diff --git a/utils.py b/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..5498289425bb70e959c0194eb7c6fab63e0c045a --- /dev/null +++ b/utils.py @@ -0,0 +1,92 @@ +# Copyright 2020 Erik Härkönen. All rights reserved. +# This file is licensed to you under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. You may obtain a copy +# of the License at http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software distributed under +# the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS +# OF ANY KIND, either express or implied. See the License for the specific language +# governing permissions and limitations under the License. + +import string +import numpy as np +from pathlib import Path +import requests +import pickle +import sys +import re +import gdown + +def prettify_name(name): + valid = "-_%s%s" % (string.ascii_letters, string.digits) + return ''.join(map(lambda c : c if c in valid else '_', name)) + +# Add padding to sequence of images +# Used in conjunction with np.hstack/np.vstack +# By default: adds one 64th of the width of horizontal padding +def pad_frames(strip, pad_fract_horiz=64, pad_fract_vert=0, pad_value=None): + dtype = strip[0].dtype + if pad_value is None: + if dtype in [np.float32, np.float64]: + pad_value = 1.0 + else: + pad_value = np.iinfo(dtype).max + + frames = [strip[0]] + for frame in strip[1:]: + if pad_fract_horiz > 0: + frames.append(pad_value*np.ones((frame.shape[0], frame.shape[1]//pad_fract_horiz, 3), dtype=dtype)) + elif pad_fract_vert > 0: + frames.append(pad_value*np.ones((frame.shape[0]//pad_fract_vert, frame.shape[1], 3), dtype=dtype)) + frames.append(frame) + return frames + + +def download_google_drive(url, output_name): + print('Downloading', url) + gdown.download(url, str(output_name)) + # session = requests.Session() + # r = session.get(url, allow_redirects=True) + # r.raise_for_status() + + # # Google Drive virus check message + # if r.encoding is not None: + # tokens = re.search('(confirm=.+)&id', str(r.content)) + # assert tokens is not None, 'Could not extract token from response' + + # url = url.replace('id=', f'{tokens[1]}&id=') + # r = session.get(url, allow_redirects=True) + # r.raise_for_status() + + # assert r.encoding is None, f'Failed to download weight file from {url}' + + # with open(output_name, 'wb') as f: + # f.write(r.content) + +def download_generic(url, output_name): + print('Downloading', url) + session = requests.Session() + r = session.get(url, allow_redirects=True) + r.raise_for_status() + + # No encoding means raw data + if r.encoding is None: + with open(output_name, 'wb') as f: + f.write(r.content) + else: + download_manual(url, output_name) + +def download_manual(url, output_name): + outpath = Path(output_name).resolve() + while not outpath.is_file(): + print('Could not find checkpoint') + print(f'Please download the checkpoint from\n{url}\nand save it as\n{outpath}') + input('Press any key to continue...') + +def download_ckpt(url, output_name): + if 'drive.google' in url: + download_google_drive(url, output_name) + elif 'mega.nz' in url: + download_manual(url, output_name) + else: + download_generic(url, output_name) \ No newline at end of file diff --git a/visualize.py b/visualize.py new file mode 100644 index 0000000000000000000000000000000000000000..433ae2ea8963c56a37e5e91932ad6d359495ed47 --- /dev/null +++ b/visualize.py @@ -0,0 +1,314 @@ +# Copyright 2020 Erik Härkönen. All rights reserved. +# This file is licensed to you under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. You may obtain a copy +# of the License at http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software distributed under +# the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS +# OF ANY KIND, either express or implied. See the License for the specific language +# governing permissions and limitations under the License. + +# Patch for broken CTRL+C handler +# https://github.com/ContinuumIO/anaconda-issues/issues/905 +import os +os.environ['FOR_DISABLE_CONSOLE_CTRL_HANDLER'] = '1' + +import torch, json, numpy as np +from types import SimpleNamespace +import matplotlib.pyplot as plt +from pathlib import Path +from os import makedirs +from PIL import Image +from netdissect import proggan, nethook, easydict, zdataset +from netdissect.modelconfig import create_instrumented_model +from estimators import get_estimator +from models import get_instrumented_model +from scipy.cluster.vq import kmeans +import re +import sys +import datetime +import argparse +from tqdm import trange +from config import Config +from decomposition import get_random_dirs, get_or_compute, get_max_batch_size, SEED_VISUALIZATION +from utils import pad_frames + +def x_closest(p): + distances = np.sqrt(np.sum((X - p)**2, axis=-1)) + idx = np.argmin(distances) + return distances[idx], X[idx] + +def make_gif(imgs, duration_secs, outname): + head, *tail = [Image.fromarray((x * 255).astype(np.uint8)) for x in imgs] + ms_per_frame = 1000 * duration_secs / instances + head.save(outname, format='GIF', append_images=tail, save_all=True, duration=ms_per_frame, loop=0) + +def make_mp4(imgs, duration_secs, outname): + import shutil + import subprocess as sp + + FFMPEG_BIN = shutil.which("ffmpeg") + assert FFMPEG_BIN is not None, 'ffmpeg not found, install with "conda install -c conda-forge ffmpeg"' + assert len(imgs[0].shape) == 3, 'Invalid shape of frame data' + + resolution = imgs[0].shape[0:2] + fps = int(len(imgs) / duration_secs) + + command = [ FFMPEG_BIN, + '-y', # overwrite output file + '-f', 'rawvideo', + '-vcodec','rawvideo', + '-s', f'{resolution[0]}x{resolution[1]}', # size of one frame + '-pix_fmt', 'rgb24', + '-r', f'{fps}', + '-i', '-', # imput from pipe + '-an', # no audio + '-c:v', 'libx264', + '-preset', 'slow', + '-crf', '17', + str(Path(outname).with_suffix('.mp4')) ] + + frame_data = np.concatenate([(x * 255).astype(np.uint8).reshape(-1) for x in imgs]) + with sp.Popen(command, stdin=sp.PIPE, stdout=sp.PIPE, stderr=sp.PIPE) as p: + ret = p.communicate(frame_data.tobytes()) + if p.returncode != 0: + print(ret[1].decode("utf-8")) + raise sp.CalledProcessError(p.returncode, command) + + +def make_grid(latent, lat_mean, lat_comp, lat_stdev, act_mean, act_comp, act_stdev, scale=1, n_rows=10, n_cols=5, make_plots=True, edit_type='latent'): + from notebooks.notebook_utils import create_strip_centered + + inst.remove_edits() + x_range = np.linspace(-scale, scale, n_cols, dtype=np.float32) # scale in sigmas + + rows = [] + for r in range(n_rows): + curr_row = [] + out_batch = create_strip_centered(inst, edit_type, layer_key, [latent], + act_comp[r], lat_comp[r], act_stdev[r], lat_stdev[r], act_mean, lat_mean, scale, 0, -1, n_cols)[0] + for i, img in enumerate(out_batch): + curr_row.append(('c{}_{:.2f}'.format(r, x_range[i]), img)) + + rows.append(curr_row[:n_cols]) + + inst.remove_edits() + + if make_plots: + # If more rows than columns, make several blocks side by side + n_blocks = 2 if n_rows > n_cols else 1 + + for r, data in enumerate(rows): + # Add white borders + imgs = pad_frames([img for _, img in data]) + + coord = ((r * n_blocks) % n_rows) + ((r * n_blocks) // n_rows) + plt.subplot(n_rows//n_blocks, n_blocks, 1 + coord) + plt.imshow(np.hstack(imgs)) + + # Custom x-axis labels + W = imgs[0].shape[1] # image width + P = imgs[1].shape[1] # padding width + locs = [(0.5*W + i*(W+P)) for i in range(n_cols)] + plt.xticks(locs, ["{:.2f}".format(v) for v in x_range]) + plt.yticks([]) + plt.ylabel(f'C{r}') + + plt.tight_layout() + plt.subplots_adjust(top=0.96) # make room for suptitle + + return [img for row in rows for img in row] + + +###################### +### Visualize results +###################### + +if __name__ == '__main__': + global max_batch, sample_shape, feature_shape, inst, args, layer_key, model + + args = Config().from_args() + t_start = datetime.datetime.now() + timestamp = lambda : datetime.datetime.now().strftime("%d.%m %H:%M") + print(f'[{timestamp()}] {args.model}, {args.layer}, {args.estimator}') + + # Ensure reproducibility + torch.manual_seed(0) # also sets cuda seeds + np.random.seed(0) + + # Speed up backend + torch.backends.cudnn.benchmark = True + torch.autograd.set_grad_enabled(False) + + has_gpu = torch.cuda.is_available() + device = torch.device('cuda' if has_gpu else 'cpu') + layer_key = args.layer + layer_name = layer_key #layer_key.lower().split('.')[-1] + + basedir = Path(__file__).parent.resolve() + outdir = basedir / 'out' + + # Load model + inst = get_instrumented_model(args.model, args.output_class, layer_key, device, use_w=args.use_w) + model = inst.model + feature_shape = inst.feature_shape[layer_key] + latent_shape = model.get_latent_shape() + print('Feature shape:', feature_shape) + + # Layout of activations + if len(feature_shape) != 4: # non-spatial + axis_mask = np.ones(len(feature_shape), dtype=np.int32) + else: + axis_mask = np.array([0, 1, 1, 1]) # only batch fixed => whole activation volume used + + # Shape of sample passed to PCA + sample_shape = feature_shape*axis_mask + sample_shape[sample_shape == 0] = 1 + + # Load or compute components + dump_name = get_or_compute(args, inst) + data = np.load(dump_name, allow_pickle=False) # does not contain object arrays + X_comp = data['act_comp'] + X_global_mean = data['act_mean'] + X_stdev = data['act_stdev'] + X_var_ratio = data['var_ratio'] + X_stdev_random = data['random_stdevs'] + Z_global_mean = data['lat_mean'] + Z_comp = data['lat_comp'] + Z_stdev = data['lat_stdev'] + n_comp = X_comp.shape[0] + data.close() + + # Transfer components to device + tensors = SimpleNamespace( + X_comp = torch.from_numpy(X_comp).to(device).float(), #-1, 1, C, H, W + X_global_mean = torch.from_numpy(X_global_mean).to(device).float(), # 1, C, H, W + X_stdev = torch.from_numpy(X_stdev).to(device).float(), + Z_comp = torch.from_numpy(Z_comp).to(device).float(), + Z_stdev = torch.from_numpy(Z_stdev).to(device).float(), + Z_global_mean = torch.from_numpy(Z_global_mean).to(device).float(), + ) + + transformer = get_estimator(args.estimator, n_comp, args.sparsity) + tr_param_str = transformer.get_param_str() + + # Compute max batch size given VRAM usage + max_batch = args.batch_size or (get_max_batch_size(inst, device) if has_gpu else 1) + print('Batch size:', max_batch) + + def show(): + if args.batch_mode: + plt.close('all') + else: + plt.show() + + print(f'[{timestamp()}] Creating visualizations') + + # Ensure visualization gets new samples + torch.manual_seed(SEED_VISUALIZATION) + np.random.seed(SEED_VISUALIZATION) + + # Make output directories + est_id = f'spca_{args.sparsity}' if args.estimator == 'spca' else args.estimator + outdir_comp = outdir/model.name/layer_key.lower()/est_id/'comp' + outdir_inst = outdir/model.name/layer_key.lower()/est_id/'inst' + outdir_summ = outdir/model.name/layer_key.lower()/est_id/'summ' + makedirs(outdir_comp, exist_ok=True) + makedirs(outdir_inst, exist_ok=True) + makedirs(outdir_summ, exist_ok=True) + + # Measure component sparsity (!= activation sparsity) + sparsity = np.mean(X_comp == 0) # percentage of zero values in components + print(f'Sparsity: {sparsity:.2f}') + + def get_edit_name(mode): + if mode == 'activation': + is_stylegan = 'StyleGAN' in args.model + is_w = layer_key in ['style', 'g_mapping'] + return 'W' if (is_stylegan and is_w) else 'ACT' + elif mode == 'latent': + return model.latent_space_name() + elif mode == 'both': + return 'BOTH' + else: + raise RuntimeError(f'Unknown edit mode {mode}') + + # Only visualize applicable edit modes + if args.use_w and layer_key in ['style', 'g_mapping']: + edit_modes = ['latent'] # activation edit is the same + else: + edit_modes = ['activation', 'latent'] + + # Summary grid, real components + for edit_mode in edit_modes: + plt.figure(figsize = (14,12)) + plt.suptitle(f"{args.estimator.upper()}: {model.name} - {layer_name}, {get_edit_name(edit_mode)} edit", size=16) + make_grid(tensors.Z_global_mean, tensors.Z_global_mean, tensors.Z_comp, tensors.Z_stdev, tensors.X_global_mean, + tensors.X_comp, tensors.X_stdev, scale=args.sigma, edit_type=edit_mode, n_rows=14) + plt.savefig(outdir_summ / f'components_{get_edit_name(edit_mode)}.jpg', dpi=300) + show() + + if args.make_video: + components = 15 + instances = 150 + + # One reasonable, one over the top + for sigma in [args.sigma, 3*args.sigma]: + for c in range(components): + for edit_mode in edit_modes: + frames = make_grid(tensors.Z_global_mean, tensors.Z_global_mean, tensors.Z_comp[c:c+1, :, :], tensors.Z_stdev[c:c+1], tensors.X_global_mean, + tensors.X_comp[c:c+1, :, :], tensors.X_stdev[c:c+1], n_rows=1, n_cols=instances, scale=sigma, make_plots=False, edit_type=edit_mode) + plt.close('all') + + frames = [x for _, x in frames] + frames = frames + frames[::-1] + make_mp4(frames, 5, outdir_comp / f'{get_edit_name(edit_mode)}_sigma{sigma}_comp{c}.mp4') + + + # Summary grid, random directions + # Using the stdevs of the principal components for same norm + random_dirs_act = torch.from_numpy(get_random_dirs(n_comp, np.prod(sample_shape)).reshape(-1, *sample_shape)).to(device) + random_dirs_z = torch.from_numpy(get_random_dirs(n_comp, np.prod(inst.input_shape)).reshape(-1, *latent_shape)).to(device) + + for edit_mode in edit_modes: + plt.figure(figsize = (14,12)) + plt.suptitle(f"{model.name} - {layer_name}, random directions w/ PC stdevs, {get_edit_name(edit_mode)} edit", size=16) + make_grid(tensors.Z_global_mean, tensors.Z_global_mean, random_dirs_z, tensors.Z_stdev, + tensors.X_global_mean, random_dirs_act, tensors.X_stdev, scale=args.sigma, edit_type=edit_mode, n_rows=14) + plt.savefig(outdir_summ / f'random_dirs_{get_edit_name(edit_mode)}.jpg', dpi=300) + show() + + # Random instances w/ components added + n_random_imgs = 10 + latents = model.sample_latent(n_samples=n_random_imgs) + + for img_idx in trange(n_random_imgs, desc='Random images', ascii=True): + #print(f'Creating visualizations for random image {img_idx+1}/{n_random_imgs}') + z = latents[img_idx][None, ...] + + # Summary grid, real components + for edit_mode in edit_modes: + plt.figure(figsize = (14,12)) + plt.suptitle(f"{args.estimator.upper()}: {model.name} - {layer_name}, {get_edit_name(edit_mode)} edit", size=16) + make_grid(z, tensors.Z_global_mean, tensors.Z_comp, tensors.Z_stdev, + tensors.X_global_mean, tensors.X_comp, tensors.X_stdev, scale=args.sigma, edit_type=edit_mode, n_rows=14) + plt.savefig(outdir_summ / f'samp{img_idx}_real_{get_edit_name(edit_mode)}.jpg', dpi=300) + show() + + if args.make_video: + components = 5 + instances = 150 + + # One reasonable, one over the top + for sigma in [args.sigma, 3*args.sigma]: #[2, 5]: + for edit_mode in edit_modes: + imgs = make_grid(z, tensors.Z_global_mean, tensors.Z_comp, tensors.Z_stdev, tensors.X_global_mean, tensors.X_comp, tensors.X_stdev, + n_rows=components, n_cols=instances, scale=sigma, make_plots=False, edit_type=edit_mode) + plt.close('all') + + for c in range(components): + frames = [x for _, x in imgs[c*instances:(c+1)*instances]] + frames = frames + frames[::-1] + make_mp4(frames, 5, outdir_inst / f'{get_edit_name(edit_mode)}_sigma{sigma}_img{img_idx}_comp{c}.mp4') + + print('Done in', datetime.datetime.now() - t_start) \ No newline at end of file