diff --git a/projects/styleGAN2/README.md b/projects/styleGAN2/README.md new file mode 100644 index 0000000..6f84fee --- /dev/null +++ b/projects/styleGAN2/README.md @@ -0,0 +1,7 @@ +0. Install deps to run clip and stylegan2-ada-pytorch in a python virtual env. +1. Install deps from stylegan2-ada-pytorch repo. Major ones are pytorch >= 1.7 and CUDA >= 11.0 +2. Download ffhq-pretrained stylegan2 model from the above repo. +3. Use the virtual environment from above and Run through generation_demo.ipynb - this code samples images from +a styleGAN2 network and scores them using CLIP +4. ganalyze_with_clip.py is the main code that runs the steering pipeline with a generative model and CLIP. Change output +paths and model paths from within the code. \ No newline at end of file diff --git a/projects/styleGAN2/__init__.py b/projects/styleGAN2/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/projects/styleGAN2/clip_classifier_utils.py b/projects/styleGAN2/clip_classifier_utils.py new file mode 100644 index 0000000..321352c --- /dev/null +++ b/projects/styleGAN2/clip_classifier_utils.py @@ -0,0 +1,127 @@ +import gzip +import html +import os +from functools import lru_cache + +import ftfy +import regex as re + + +@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 = "../pretrained/bpe_simple_vocab_16e6.txt.gz"): + 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 \ No newline at end of file diff --git a/projects/styleGAN2/ganalyze_common_utils.py b/projects/styleGAN2/ganalyze_common_utils.py new file mode 100644 index 0000000..6dc555c --- /dev/null +++ b/projects/styleGAN2/ganalyze_common_utils.py @@ -0,0 +1,73 @@ +import numpy as np +from scipy.stats import truncnorm +import PIL.ImageDraw +import PIL.ImageFont + + +def truncated_z_sample(batch_size, dim_z, truncation=1): + values = truncnorm.rvs(-2, 2, size=(batch_size, dim_z)) + return truncation * values + +def imgrid(imarray, cols=5, pad=1): + if imarray.dtype != np.uint8: + imarray = np.uint8(imarray) + # raise ValueError('imgrid input imarray must be uint8') + pad = int(pad) + assert pad >= 0 + cols = int(cols) + assert cols >= 1 + N, H, W, C = imarray.shape + rows = int(np.ceil(N / float(cols))) + batch_pad = rows * cols - N + assert batch_pad >= 0 + post_pad = [batch_pad, pad, pad, 0] + pad_arg = [[0, p] for p in post_pad] + imarray = np.pad(imarray, pad_arg, 'constant', constant_values=255) + H += pad + W += pad + grid = (imarray + .reshape(rows, cols, H, W, C) + .transpose(0, 2, 1, 3, 4) + .reshape(rows * H, cols * W, C)) + if pad: + grid = grid[:-pad, :-pad] + return grid + +def annotate_outscore(array, outscore): + for i in range(array.shape[0]): + I = PIL.Image.fromarray(np.uint8(array[i,:,:,:])) + draw = PIL.ImageDraw.Draw(I) + font = PIL.ImageFont.truetype("/data/scratch/swamiviv/projects/stylegan2-ada-pytorch/clip_steering/arial.ttf", int(array.shape[1]/8.5)) + message = str(round(np.squeeze(outscore)[i], 2)) + x, y = (0, 0) + w, h = font.getsize(message) + #print(w, h) + draw.rectangle((x, y, x + w, y + h), fill='white') + draw.text((x, y), message, fill="black", font=font) + array[i, :, :, :] = np.array(I) + return(array) + + +class AverageMeter(object): + """Computes and stores the average and current value""" + + def __init__(self, name, fmt=':f'): + self.name = name + self.fmt = fmt + self.reset() + + def reset(self): + self.val = 0 + self.avg = 0 + self.sum = 0 + self.count = 0 + + def update(self, val, n=1): + self.val = val + self.sum += val * n + self.count += n + self.avg = self.sum / self.count + + def __str__(self): + fmtstr = '{name} {val' + self.fmt + '} ({avg' + self.fmt + '})' + return fmtstr.format(**self.__dict__) \ No newline at end of file diff --git a/projects/styleGAN2/ganalyze_transformations.py b/projects/styleGAN2/ganalyze_transformations.py new file mode 100644 index 0000000..882e7af --- /dev/null +++ b/projects/styleGAN2/ganalyze_transformations.py @@ -0,0 +1,58 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +import numpy as np +import math +import scipy.io as sio + +class OneDirection(nn.Module): + def __init__(self,dim_z,vocab_size=1000, **kwargs): + super(OneDirection, self).__init__() + print("\napproach: ", "one_direction\n") + self.dim_z = dim_z + self.vocab_size = vocab_size + self.w = nn.Parameter(torch.randn(1, self.dim_z)) + self.criterion = nn.MSELoss() + + + def transform(self,z,y,step_sizes,**kwargs): + if y is not None: + assert(len(y) == z.shape[0]) + + interim = step_sizes * self.w + + z_transformed = z + interim + z_transformed = z.norm() * z_transformed / z_transformed.norm() + + return(z_transformed) + + def compute_loss(self, current, target, batch_start, lossfile): + loss = self.criterion(current,target) + with open(lossfile, 'a') as file: + file.writelines(str(batch_start)+",mse_loss,"+str(loss)+"\n") + file.writelines(str(batch_start) + ",overall_loss," + str(loss)+"\n") + return loss + +class ClassDependent(nn.Module): + def __init__(self,dim_z,vocab_size=1000, **kwargs): + super(ClassDependent, self).__init__() + print("\napproach: ", "class_dependent\n") + self.dim_z = dim_z + self.vocab_size = vocab_size + self.NN_output = nn.Linear(self.vocab_size, self.dim_z) + self.criterion = nn.MSELoss() + + + def transform(self,z,y,step_sizes,**kwargs): + assert (y is not None) + interim = step_sizes * self.NN_output(y) + z_transformed = z + interim + z_transformed = z.norm() * z_transformed / z_transformed.norm() + return(z_transformed) + + def compute_loss(self, current, target, batch_start, lossfile): + loss = self.criterion(current,target) + with open(lossfile, 'a') as file: + file.writelines(str(batch_start)+",mse_loss,"+str(loss)+"\n") + file.writelines(str(batch_start) + ",overall_loss," + str(loss)+"\n") + return loss \ No newline at end of file diff --git a/projects/styleGAN2/ganalyze_with_clip.py b/projects/styleGAN2/ganalyze_with_clip.py new file mode 100644 index 0000000..fe2a129 --- /dev/null +++ b/projects/styleGAN2/ganalyze_with_clip.py @@ -0,0 +1,202 @@ +import argparse +import json +import subprocess +import sys +import numpy as np +import torch +import torch.nn.functional as F +import torchvision.transforms as torch_transforms +import ganalyze_transformations as transformations +import ganalyze_common_utils as common +import pickle +import os +import pathlib +sys.path.append(os.path.abspath(os.getcwd())) +sys.path.append('/data/scratch/swamiviv/projects/stylegan2-ada-pytorch/') +from clip_classifier_utils import SimpleTokenizer +import logging +logging.basicConfig( + format='%(asctime)s %(levelname)-8s %(message)s', + level=logging.INFO, + datefmt='%Y-%m-%d %H:%M:%S', +) + +logger = logging.getLogger(__name__) +device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + +def gan_output_transform(imgs): + # Input: + # img: NCHW + # + # Output + # img_np: HWC RGB image + + imgs = (imgs * 127.5 + 128).clamp(0, 255).float() + return imgs + + +def clip_input_transform(images): + # Input + # img_np: torch tensor of shape NHWC, RGB image + # + # Output + # image_input: torch tensor of shape NHWC + + image_mean = (0.48145466, 0.4578275, 0.40821073) + image_std = (0.26862954, 0.26130258, 0.27577711) + + transform = torch.nn.Sequential( + torch_transforms.Resize((256, 256)), + torch_transforms.CenterCrop((224, 224)), + torch_transforms.Normalize(image_mean, image_std), + ) + + return transform(images) + +def get_clip_scores(image_inputs, encoded_text, model, class_index=0): + #TODO: clarify class index + image_inputs = clip_input_transform(image_inputs).to(device) + image_feats = model.encode_image(image_inputs).float() + image_feats = F.normalize(image_feats, p=2, dim=-1) + + similarity_scores = torch.matmul(image_feats, torch.transpose(encoded_text, 0, 1)) + similarity_scores = similarity_scores.to(device) + return similarity_scores.narrow(dim=-1, start=class_index, length=1).squeeze(dim=-1) + +def get_clip_probs(image_inputs, encoded_text, model, class_index=0): + image_inputs = clip_input_transform(image_inputs).to(device) + image_feats = model.encode_image(image_inputs).float() + image_feats = F.normalize(image_feats, p=2, dim=-1) + + clip_probs = (100.0 * torch.matmul(image_feats, torch.transpose(encoded_text, 0, 1))).softmax(dim=-1) + clip_probs = clip_probs.to(device) + + return clip_probs.narrow(dim=-1, start=class_index, length=1).squeeze(dim=-1) + +# Set up GAN +gan_model_path = '../pretrained/ffhq.pkl' +# Initialize GAN generator and transforms +with open(gan_model_path, 'rb') as f: + G = pickle.load(f)['G_ema'] +G.eval() +G.to(device) +latent_space_dim = G.z_dim + +# Set up clip classifier +clip_model_path = '../pretrained/clip_ViT-B-32.pt' +clip_model = torch.jit.load(clip_model_path) +clip_model.eval() +clip_model.to(device) +input_resolution = clip_model.input_resolution.item() +context_length = clip_model.context_length.item() +vocab_size = clip_model.vocab_size.item() + +print("Model parameters:", f"{np.sum([int(np.prod(p.shape)) for p in clip_model.parameters()]):,}") +print("Input resolution:", input_resolution) +print("Context length:", context_length) +print("Vocab size:", vocab_size) + +# Extract text features for clip +attributes = ["an evil face", "a radiant face", "a criminal face", "a beautiful face", "a handsome face", "a smart face"] +class_index = 2 #which attribute do we want to maximize +tokenizer = SimpleTokenizer() +sot_token = tokenizer.encoder['<|startoftext|>'] +eot_token = tokenizer.encoder['<|endoftext|>'] +text_descriptions = [f"This is a photo of {label}" for label in attributes] +text_tokens = [[sot_token] + tokenizer.encode(desc) + [eot_token] for desc in text_descriptions] +text_inputs = torch.zeros(len(text_tokens), clip_model.context_length, dtype=torch.long) + +for i, tokens in enumerate(text_tokens): + text_inputs[i, :len(tokens)] = torch.tensor(tokens) + +# These are held constant through the optimization, akin to labels +text_inputs = text_inputs.to(device) +with torch.no_grad(): + text_features = clip_model.encode_text(text_inputs).float() + text_features = F.normalize(text_features, p=2, dim=-1) +text_features.to(device) + +# Setting up Transformer +# -------------------------------------------------------------------------------------------------------------- +transformer_params = ['OneDirection', 'None'] +transformer = transformer_params[0] +transformer_arguments = transformer_params[1] +if transformer_arguments != "None": + key_value_pairs = transformer_arguments.split(",") + key_value_pairs = [pair.split("=") for pair in key_value_pairs] + transformer_arguments = {pair[0]: pair[1] for pair in key_value_pairs} +else: + transformer_arguments = {} + +transformation = getattr(transformations, transformer)(latent_space_dim, vocab_size, **transformer_arguments) +transformation = transformation.to(device) + +# function that is used to score the (attribute, image) pair +scoring_fun = get_clip_probs + + +# Training +# -------------------------------------------------------------------------------------------------------------- +# optimizer +optimizer = torch.optim.Adam(transformation.parameters(), lr=0.0002) +losses = common.AverageMeter(name='Loss') + +# training settings +optim_iter = 0 +batch_size = 6 +train_alpha_a = -0.5 # Lower limit for step sizes +train_alpha_b = 0.5 # Upper limit for step sizes +num_samples = 400000 # Number of samples to train for + +# create training set +#np.random.seed(seed=0) +truncation = 1 +zs = common.truncated_z_sample(num_samples, latent_space_dim, truncation) + +checkpoint_dir = f'/data/scratch/swamiviv/projects/stylegan2-ada-pytorch/clip_steering/results_maximize_{attributes[class_index]}_probability' +pathlib.Path(checkpoint_dir).mkdir(parents=True, exist_ok=True) + +# loop over data batches +for batch_start in range(0, num_samples, batch_size): + + # input batch + s = slice(batch_start, min(num_samples, batch_start + batch_size)) + z = torch.from_numpy(zs[s]).type(torch.FloatTensor).to(device) + y = None + step_sizes = (train_alpha_b - train_alpha_a) * \ + np.random.random(size=(batch_size)) + train_alpha_a # sample step_sizes + step_sizes_broadcast = np.repeat(step_sizes, latent_space_dim).reshape([batch_size, latent_space_dim]) + step_sizes_broadcast = torch.from_numpy(step_sizes_broadcast).type(torch.FloatTensor).to(device) + + # ganalyze steps + gan_images = G(z, None) + gan_images = gan_output_transform(gan_images) + out_scores = scoring_fun( + image_inputs=gan_images, encoded_text=text_features, model=clip_model, class_index=class_index, + ) + # TODO: ignore z vectors with less confident clip scores + target_scores = out_scores + torch.from_numpy(step_sizes).to(device).float() + + z_transformed = transformation.transform(z, None, step_sizes_broadcast) + gan_images_transformed = G(z_transformed, None) + gan_images_transformed = gan_output_transform(gan_images_transformed).to(device) + out_scores_transformed = scoring_fun( + image_inputs=gan_images_transformed, encoded_text=text_features, model=clip_model, class_index=class_index, + ).to(device).float() + + # compute loss + loss = transformation.criterion(out_scores_transformed, target_scores) + + # backwards + loss.backward() + optimizer.step() + + # print loss + losses.update(loss.item(), batch_size) + if optim_iter % 100 == 0: + logger.info(f'[Maximizing score for {attributes[class_index]}] Progress: [{batch_start}/{num_samples}] {losses}') + + if optim_iter % 500 == 0: + logger.info(f"saving checkpoint at iteration {optim_iter}") + torch.save(transformation.state_dict(), os.path.join(checkpoint_dir, "pytorch_model_{}.pth".format(batch_start))) + optim_iter = optim_iter + 1 diff --git a/projects/styleGAN2/generation_demo.ipynb b/projects/styleGAN2/generation_demo.ipynb new file mode 100644 index 0000000..b4c9924 --- /dev/null +++ b/projects/styleGAN2/generation_demo.ipynb @@ -0,0 +1,636 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import pickle\n", + "import os\n", + "os.environ[\"CUDA_DEVICE_ORDER\"]=\"PCI_BUS_ID\"\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"3\"\n", + "import sys\n", + "sys.path.append(os.path.abspath(os.getcwd()))\n", + "from clip_steering.clip_classifier_utils import SimpleTokenizer\n", + "\n", + "import numpy as np\n", + "from PIL import Image" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "with open('pretrained/ffhq.pkl', 'rb') as f:\n", + " G = pickle.load(f)['G_ema'].cuda() # torch.nn.Module" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setting up PyTorch plugin \"bias_act_plugin\"... Done.\n", + "Setting up PyTorch plugin \"upfirdn2d_plugin\"... Done.\n", + "0 255\n" + ] + }, + { + "data": { + "text/plain": [ + "(1024, 1024, 3)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "z = torch.randn([1, G.z_dim]).cuda() # latent codes\n", + "c = None # class labels (not used in this example)\n", + "img = G(z, c) # NCHW, float32, dynamic range [-1, +1]\n", + "\n", + "img = (img.permute(0, 2, 3, 1) * 127.5 + 128).clamp(0, 255).to(torch.uint8)\n", + "img_np = img.detach().cpu().numpy().squeeze()\n", + "print(img_np.min(), img_np.max())\n", + "img_np.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(img_np)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model parameters: 151,277,313\n", + "Input resolution: 224\n", + "Context length: 77\n", + "Vocab size: 49408\n" + ] + } + ], + "source": [ + "# Set up clip classifier\n", + "\n", + "clip_model_path = 'pretrained/clip_ViT-B-32.pt'\n", + "model = torch.jit.load(clip_model_path).cuda().eval()\n", + "input_resolution = model.input_resolution.item()\n", + "context_length = model.context_length.item()\n", + "vocab_size = model.vocab_size.item()\n", + "\n", + "print(\"Model parameters:\", f\"{np.sum([int(np.prod(p.shape)) for p in model.parameters()]):,}\")\n", + "print(\"Input resolution:\", input_resolution)\n", + "print(\"Context length:\", context_length)\n", + "print(\"Vocab size:\", vocab_size)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/data/scratch/swamiviv/.envs/pytorch-1.8/lib/python3.7/site-packages/torchvision/transforms/transforms.py:258: UserWarning: Argument interpolation should be of type InterpolationMode instead of int. Please, use InterpolationMode enum.\n", + " \"Argument interpolation should be of type InterpolationMode instead of int. \"\n" + ] + } + ], + "source": [ + "# Image preprocessing\n", + "from torchvision.transforms import Compose, Resize, CenterCrop, ToTensor, Normalize\n", + "from PIL import Image\n", + "\n", + "preprocess = Compose([\n", + " Resize(input_resolution, interpolation=Image.BICUBIC),\n", + " CenterCrop(input_resolution),\n", + " ToTensor()\n", + "])\n", + "\n", + "image_mean = torch.tensor([0.48145466, 0.4578275, 0.40821073]).cuda()\n", + "image_std = torch.tensor([0.26862954, 0.26130258, 0.27577711]).cuda()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Building features for clip\n", + "attributes = [\"an evil face\", \"a radiant face\", \"a criminal face\", \"a beautiful face\", \"a handsome face\", \"a smart face\"]\n", + "tokenizer = SimpleTokenizer()\n", + "text_tokens = [tokenizer.encode(\"This person has \" + desc) for desc in attributes]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "text_input = torch.zeros(len(text_tokens), model.context_length, dtype=torch.long)\n", + "sot_token = tokenizer.encoder['<|startoftext|>']\n", + "eot_token = tokenizer.encoder['<|endoftext|>']\n", + "\n", + "for i, tokens in enumerate(text_tokens):\n", + " tokens = [sot_token] + tokens + [eot_token]\n", + " text_input[i, :len(tokens)] = torch.tensor(tokens)\n", + "\n", + "text_input = text_input.cuda()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setting up PyTorch plugin \"bias_act_plugin\"... Done.\n", + "Setting up PyTorch plugin \"upfirdn2d_plugin\"... Done.\n", + "Done: 0 / 1000\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "nsamples = 1000\n", + "\n", + "relevant_stats = {\n", + " 'latent_z': [],\n", + " 'similarity': [],\n", + " 'top_bottom_diff': [],\n", + " 'prediction': []\n", + "}\n", + "\n", + "for snum in range(nsamples):\n", + " z = torch.randn([1, G.z_dim]).cuda() # latent codes\n", + " c = None \n", + " img = G(z, c) # NCHW, float32, dynamic range [-1, +1]\n", + " img = (img.permute(0, 2, 3, 1) * 127.5 + 128).clamp(0, 255).to(torch.uint8)\n", + " img_np = img.detach().cpu().numpy().squeeze()\n", + "\n", + " image_input = preprocess(Image.fromarray(img_np.astype(np.uint8))).to('cuda')\n", + " image_input -= image_mean[:, None, None]\n", + " image_input /= image_std[:, None, None]\n", + "\n", + " with torch.no_grad():\n", + " image_features = model.encode_image(image_input.unsqueeze(0)).float()\n", + " text_features = model.encode_text(text_input).float()\n", + "\n", + " image_features /= image_features.norm(dim=-1, keepdim=True)\n", + " text_features /= text_features.norm(dim=-1, keepdim=True)\n", + " similarity = text_features.cpu().numpy() @ image_features.cpu().numpy().T\n", + "\n", + " top_bottom_diff = similarity.max() - similarity.min()\n", + " prediction = attributes[np.argmax(similarity)]\n", + " \n", + " if top_bottom_diff > 0.02:\n", + " relevant_stats['latent_z'].append(z.detach().cpu().numpy())\n", + " relevant_stats['similarity'].append(similarity)\n", + " relevant_stats['top_bottom_diff'].append(top_bottom_diff)\n", + " relevant_stats['prediction'].append(prediction)\n", + " \n", + " if snum % 200 == 0:\n", + " print(f'Done: {snum} / {nsamples}')\n", + "\n", + "df = pd.DataFrame(relevant_stats)" + ] + }, + { + "cell_type": "code", + "execution_count": 166, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "572" + ] + }, + "execution_count": 166, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 170, + "metadata": {}, + "outputs": [], + "source": [ + "sorted_df = df.sort_values(by='top_bottom_diff', ascending=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 188, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['an evil face', 'a radiant face', 'a criminal face', 'a beautiful face', 'a handsome face', 'a smart face']\n", + "[[0.21433859]\n", + " [0.19476883]\n", + " [0.22296181]\n", + " [0.21364272]\n", + " [0.19977207]\n", + " [0.18491983]]\n", + "a criminal face\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "idx = 17\n", + "z = torch.Tensor(sorted_df.iloc[idx]['latent_z']).cuda() # latent codes\n", + "similarity = sorted_df.iloc[idx]['similarity']\n", + "prediction = sorted_df.iloc[idx]['prediction']\n", + "c = None \n", + "img = G(z, c) # NCHW, float32, dynamic range [-1, +1]\n", + "img = (img.permute(0, 2, 3, 1) * 127.5 + 128).clamp(0, 255).to(torch.uint8)\n", + "img_np = img.detach().cpu().numpy().squeeze()\n", + "\n", + "plt.imshow(img_np)\n", + "print(attributes)\n", + "print(similarity)\n", + "print(prediction)" + ] + }, + { + "cell_type": "code", + "execution_count": 168, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "a beautiful face 276\n", + "a criminal face 92\n", + "a radiant face 69\n", + "a handsome face 68\n", + "an evil face 56\n", + "a smart face 11\n", + "Name: prediction, dtype: int64" + ] + }, + "execution_count": 168, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.prediction.value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 169, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
latent_zsimilaritytop_bottom_diffprediction
135[[-0.62991005, -2.6331103, 0.14792924, -1.5773...[[0.21699415], [0.22681132], [0.2277107], [0.2...0.051867a beautiful face
117[[-2.0631874, 0.460264, -1.9547219, 1.280148, ...[[0.25695124], [0.2263385], [0.2713348], [0.24...0.051864a criminal face
408[[0.10143872, 1.7803025, 0.48458585, 0.3493015...[[0.21954368], [0.23556489], [0.21290006], [0....0.046210a radiant face
178[[0.086051606, -0.9148355, -0.5573339, -0.6975...[[0.23668197], [0.21317336], [0.24430124], [0....0.045989a criminal face
409[[0.18771273, 0.054595817, -0.71061057, 0.0384...[[0.26218495], [0.24592195], [0.26309437], [0....0.043787a criminal face
374[[-0.3563394, -0.7051001, 0.9003282, 0.0331075...[[0.2061812], [0.22603615], [0.20512976], [0.2...0.043630a beautiful face
103[[-0.043942858, -0.055912673, 1.2481582, 1.103...[[0.21711786], [0.20505492], [0.24847613], [0....0.043421a criminal face
382[[-1.0258626, 0.37741572, 2.267554, 0.18668833...[[0.20888546], [0.22189918], [0.22515306], [0....0.042254a handsome face
520[[1.2128234, 0.92469555, 0.29807073, 0.5735662...[[0.23032118], [0.24256575], [0.24359804], [0....0.041668a beautiful face
263[[0.77695966, 0.043014027, -0.31055117, -1.267...[[0.24655896], [0.22578388], [0.25046957], [0....0.041442a criminal face
281[[1.1026641, 1.2241672, -0.92590433, 0.8185183...[[0.22275628], [0.2177681], [0.23774463], [0.2...0.041196a criminal face
351[[-1.4477789, 0.89100564, 0.04112493, -0.08201...[[0.25321466], [0.23728895], [0.25030193], [0....0.041162an evil face
358[[0.2689016, 0.2783102, -0.94526184, -0.580856...[[0.24100596], [0.20643993], [0.24404562], [0....0.040490a criminal face
464[[-0.6436049, 0.8607266, -1.4346567, 0.5737, -...[[0.21433485], [0.21847239], [0.22788101], [0....0.039910a beautiful face
236[[-0.18764815, -0.18946044, -0.17351027, 2.204...[[0.22532353], [0.20384519], [0.23699075], [0....0.039791a criminal face
400[[-0.5181096, 1.0081208, -0.41693178, -0.83488...[[0.21625398], [0.23244072], [0.21839073], [0....0.038600a beautiful face
505[[0.99563044, 0.53794044, 0.18033105, -1.69227...[[0.19353004], [0.17686576], [0.21500044], [0....0.038135a criminal face
37[[0.07083176, 0.5704308, -0.03981927, 0.773845...[[0.21433859], [0.19476883], [0.22296181], [0....0.038042a criminal face
286[[-1.742873, 0.3127948, 0.9414717, -0.4875157,...[[0.21975166], [0.22586168], [0.22896242], [0....0.037713a beautiful face
222[[-0.4729621, -0.40812296, -0.11271793, -0.851...[[0.22879866], [0.24111825], [0.2309012], [0.2...0.037663a beautiful face
\n", + "
" + ], + "text/plain": [ + " latent_z \\\n", + "135 [[-0.62991005, -2.6331103, 0.14792924, -1.5773... \n", + "117 [[-2.0631874, 0.460264, -1.9547219, 1.280148, ... \n", + "408 [[0.10143872, 1.7803025, 0.48458585, 0.3493015... \n", + "178 [[0.086051606, -0.9148355, -0.5573339, -0.6975... \n", + "409 [[0.18771273, 0.054595817, -0.71061057, 0.0384... \n", + "374 [[-0.3563394, -0.7051001, 0.9003282, 0.0331075... \n", + "103 [[-0.043942858, -0.055912673, 1.2481582, 1.103... \n", + "382 [[-1.0258626, 0.37741572, 2.267554, 0.18668833... \n", + "520 [[1.2128234, 0.92469555, 0.29807073, 0.5735662... \n", + "263 [[0.77695966, 0.043014027, -0.31055117, -1.267... \n", + "281 [[1.1026641, 1.2241672, -0.92590433, 0.8185183... \n", + "351 [[-1.4477789, 0.89100564, 0.04112493, -0.08201... \n", + "358 [[0.2689016, 0.2783102, -0.94526184, -0.580856... \n", + "464 [[-0.6436049, 0.8607266, -1.4346567, 0.5737, -... \n", + "236 [[-0.18764815, -0.18946044, -0.17351027, 2.204... \n", + "400 [[-0.5181096, 1.0081208, -0.41693178, -0.83488... \n", + "505 [[0.99563044, 0.53794044, 0.18033105, -1.69227... \n", + "37 [[0.07083176, 0.5704308, -0.03981927, 0.773845... \n", + "286 [[-1.742873, 0.3127948, 0.9414717, -0.4875157,... \n", + "222 [[-0.4729621, -0.40812296, -0.11271793, -0.851... \n", + "\n", + " similarity top_bottom_diff \\\n", + "135 [[0.21699415], [0.22681132], [0.2277107], [0.2... 0.051867 \n", + "117 [[0.25695124], [0.2263385], [0.2713348], [0.24... 0.051864 \n", + "408 [[0.21954368], [0.23556489], [0.21290006], [0.... 0.046210 \n", + "178 [[0.23668197], [0.21317336], [0.24430124], [0.... 0.045989 \n", + "409 [[0.26218495], [0.24592195], [0.26309437], [0.... 0.043787 \n", + "374 [[0.2061812], [0.22603615], [0.20512976], [0.2... 0.043630 \n", + "103 [[0.21711786], [0.20505492], [0.24847613], [0.... 0.043421 \n", + "382 [[0.20888546], [0.22189918], [0.22515306], [0.... 0.042254 \n", + "520 [[0.23032118], [0.24256575], [0.24359804], [0.... 0.041668 \n", + "263 [[0.24655896], [0.22578388], [0.25046957], [0.... 0.041442 \n", + "281 [[0.22275628], [0.2177681], [0.23774463], [0.2... 0.041196 \n", + "351 [[0.25321466], [0.23728895], [0.25030193], [0.... 0.041162 \n", + "358 [[0.24100596], [0.20643993], [0.24404562], [0.... 0.040490 \n", + "464 [[0.21433485], [0.21847239], [0.22788101], [0.... 0.039910 \n", + "236 [[0.22532353], [0.20384519], [0.23699075], [0.... 0.039791 \n", + "400 [[0.21625398], [0.23244072], [0.21839073], [0.... 0.038600 \n", + "505 [[0.19353004], [0.17686576], [0.21500044], [0.... 0.038135 \n", + "37 [[0.21433859], [0.19476883], [0.22296181], [0.... 0.038042 \n", + "286 [[0.21975166], [0.22586168], [0.22896242], [0.... 0.037713 \n", + "222 [[0.22879866], [0.24111825], [0.2309012], [0.2... 0.037663 \n", + "\n", + " prediction \n", + "135 a beautiful face \n", + "117 a criminal face \n", + "408 a radiant face \n", + "178 a criminal face \n", + "409 a criminal face \n", + "374 a beautiful face \n", + "103 a criminal face \n", + "382 a handsome face \n", + "520 a beautiful face \n", + "263 a criminal face \n", + "281 a criminal face \n", + "351 an evil face \n", + "358 a criminal face \n", + "464 a beautiful face \n", + "236 a criminal face \n", + "400 a beautiful face \n", + "505 a criminal face \n", + "37 a criminal face \n", + "286 a beautiful face \n", + "222 a beautiful face " + ] + }, + "execution_count": 169, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sorted_df[:20]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pytorch-1.8", + "language": "python", + "name": "pytorch-1.8" + }, + "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.10" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}