app.py

import os

import torch
import gradio as gr

import os
import sys
import numpy as np

from e4e.models.psp import pSp
from util import *
from huggingface_hub import hf_hub_download

import os
import sys
import tempfile
import shutil
from argparse import Namespace
from pathlib import Path
import shutil

import dlib
import numpy as np
import torchvision.transforms as transforms
from torchvision import utils
from PIL import Image

from model.sg2_model import Generator
from generate_videos import generate_frames, video_from_interpolations, vid_to_gif

model_dir = "models"
os.makedirs(model_dir, exist_ok=True)

models_and_paths = {"akhaliq/JoJoGAN_e4e_ffhq_encode": "e4e_ffhq_encode.pt",
                    "akhaliq/jojogan_dlib": "shape_predictor_68_face_landmarks.dat",
                    "akhaliq/jojogan-stylegan2-ffhq-config-f": "stylegan2-ffhq-config-f.pt"}

def get_models():
    os.makedirs(model_dir, exist_ok=True)

    for repo_id, file_path in models_and_paths.items():
        hf_hub_download(repo_id=repo_id, filename=file_path)
        if not "akhaliq" in repo_id:
            shutil.move(file_path, os.path.join(model_dir, file_path))
        elif "stylegan2" in file_path:
            shutil.move(file_path, os.path.join(model_dir, "base.pt"))    

    model_list = [Path(model_ckpt).stem for model_ckpt in os.listdir(model_dir)]

    return model_list

model_list = get_models()

class ImageEditor(object):
    def __init__(self):
        self.device = "cuda" if torch.cuda.is_available() else "cpu"

        latent_size = 512
        n_mlp = 8
        channel_mult = 2
        model_size = 1024

        self.generators = {}

        for model in model_list:
            g_ema = Generator(
                model_size, latent_size, n_mlp, channel_multiplier=channel_mult
            ).to(self.device)

            checkpoint = torch.load(f"models/{model}.pt")

            g_ema.load_state_dict(checkpoint['g_ema'])

            self.generators[model] = g_ema

        self.experiment_args = {"model_path": "e4e_ffhq_encode.pt"}
        self.experiment_args["transform"] = transforms.Compose(
            [
                transforms.Resize((256, 256)),
                transforms.ToTensor(),
                transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]),
            ]
        )
        self.resize_dims = (256, 256)

        model_path = self.experiment_args["model_path"]

        ckpt = torch.load(model_path, map_location="cpu")
        opts = ckpt["opts"]

        opts["checkpoint_path"] = model_path
        opts = Namespace(**opts)

        self.e4e_net = pSp(opts)
        self.e4e_net.eval()
        self.e4e_net.cuda()

        self.shape_predictor = dlib.shape_predictor(
            models_and_paths["akhaliq/jojogan_dlib"]
        )

        print("setup complete")

    def get_style_list(self):
        style_list = ['all', 'list - enter below']

        for key in self.generators:
            style_list.append(key)

        return style_list

    def predict(
        self,
        input,              # Input image path
        output_style,       # Which output style do you want to use?
        style_list,         # Comma seperated list of models to use. Only accepts models from the output_style list
        generate_video,     # Generate a video instead of an output image
        with_editing,       # Apply latent space editing to the generated video
        video_format        # Choose gif to display in browser, mp4 for higher-quality downloadable video
    ):  

        if output_style == 'all':
            styles = model_list
        elif output_style == 'list - enter below':
            styles = style_list.split(",")
            for style in styles:
                if style not in model_list:
                    raise ValueError(f"Encountered style '{style}' in the style_list which is not an available option.")
        else:
            styles = [output_style]

        # @title Align image
        input_image = self.run_alignment(str(input))
        
        input_image = input_image.resize(self.resize_dims)

        img_transforms = self.experiment_args["transform"]
        transformed_image = img_transforms(input_image)

        with torch.no_grad():
            images, latents = self.run_on_batch(transformed_image.unsqueeze(0))
            result_image, latent = images[0], latents[0]

        inverted_latent = latent.unsqueeze(0).unsqueeze(1)
        out_dir = Path(tempfile.mkdtemp())
        out_path = out_dir / "out.jpg"
        
        generators = [self.generators[style] for style in styles]

        if not generate_video:
            with torch.no_grad():
                img_list = []
                for g_ema in generators:
                    img, _ = g_ema(inverted_latent, input_is_latent=True, truncation=1, randomize_noise=False)
                    img_list.append(img)
                
                out_img = torch.cat(img_list, axis=0)
                utils.save_image(out_img, out_path, nrow=int(np.sqrt(out_img.size(0))), normalize=True, scale_each=True, range=(-1, 1))

            return Path(out_path)
        
        return self.generate_vid(generators, inverted_latent, out_dir, video_format, with_editing)

    def generate_vid(self, generators, latent, out_dir, video_format, with_editing):      
        np_latent = latent.squeeze(0).cpu().detach().numpy()
        args = {
                'fps': 24,
                'target_latents': None,
                'edit_directions': None,
                'unedited_frames': 0 if with_editing else 40 * (len(generators) - 1)
                }

        args = Namespace(**args)
        with tempfile.TemporaryDirectory() as dirpath:

            generate_frames(args, np_latent, generators, dirpath)
            video_from_interpolations(args.fps, dirpath)
            
            gen_path = Path(dirpath) / "out.mp4"
            out_path = out_dir / f"out.{video_format}"

            if video_format == 'gif':
                vid_to_gif(gen_path, out_dir, scale=256, fps=args.fps)
            else:
                shutil.copy2(gen_path, out_path) 

        return out_path

    def run_alignment(self, image_path):
        aligned_image = align_face(filepath=image_path, predictor=self.shape_predictor)
        print("Aligned image has shape: {}".format(aligned_image.size))
        return aligned_image

    def run_on_batch(self, inputs):
        images, latents = self.e4e_net(
            inputs.to("cuda").float(), randomize_noise=False, return_latents=True
        )
        return images, latents

editor = ImageEditor()

title = "StyleGAN-NADA"
description = "Gradio Demo for StyleGAN-NADA: CLIP-Guided Domain Adaptation of Image Generators (SIGGRAPH 2022). To use it, upload your image and select a target style. More information about the paper and training new models can be found below."

article = "<p style='text-align: center'><a href='https://arxiv.org/abs/2108.00946' target='_blank'>StyleGAN-NADA: CLIP-Guided Domain Adaptation of Image Generators</a> | <a href='https://stylegan-nada.github.io/' target='_blank'>Project Page</a> | <a href='https://github.com/rinongal/StyleGAN-nada' target='_blank'>Code</a></p> <center><img src='https://visitor-badge.glitch.me/badge?page_id=rinong_sgnada' alt='visitor badge'></center>"

gr.Interface(editor.predict, [gr.inputs.Image(type="pil"), 
                              gr.inputs.Dropdown(choices=editor.get_style_list(), type="value", default='base', label="Model"), 
                              gr.inputs.Textbox(lines=1, placeholder=None, default="joker,anime,modigliani", label="Style List", optional=True),
                              gr.inputs.Checkbox(default=False, label="Generate Video?", optional=False),
                              gr.inputs.Checkbox(default=False, label="With Editing?", optional=False),
                              gr.inputs.Radio(choices=["gif", "mp4"], type="value", default='mp4', label="Video Format")],
                              gr.outputs.Image(type="file"), title=title, description=description, article=article, allow_flagging=False, allow_screenshot=False).launch()