NVIDIA STYLAGAN 2 – ADA के साथ इंटरैक्टिव फोटोरलिस्टिक चेहरे बनाने के लिए एक स्टेप वाइज पायथन कोड का कार्यान्वयन

!git clone https://github.com/NVlabs/stylegan2-ada-pytorch.git

!mkdir -p stylegan2-ada-pytorch/pretrained
!wget https://nvlabs-fi-cdn.nvidia.com/stylegan2-ada-pytorch/pretrained/ffhq.pkl -O stylegan2-ada-pytorch/pretrained/ffhq.pkl

import sys
sys.path.append('stylegan2-ada-pytorch')

import torch
import numpy as np
import PIL.Image
import matplotlib.pyplot as plt
import ipywidgets as widgets
from IPython.display import display

import legacy
import dnnlib


def generate_image(seed=42, truncation=1.0, network_pkl="stylegan2-ada-pytorch/pretrained/ffhq.pkl"):
    print(f'Generating image with seed {seed} and truncation {truncation}')
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
   
    with dnnlib.util.open_url(network_pkl) as f:                                # Load the pretrained generator network
        G = legacy.load_network_pkl(f)('G_ema').to(device)
   
    z = torch.from_numpy(np.random.RandomState(seed).randn(1, G.z_dim)).to(device)   # Create a latent vector using the provided seed
    label = None  # FFHQ is unconditional


    with torch.no_grad():                                                             # Generate image
        img = G(z, label, truncation_psi=truncation, noise_mode="const")
   
    # Convert image tensor to uint8 and format for display
    img = (img + 1) * (255/2)
    img = img.clamp(0,255).to(torch.uint8)
    img = img(0).permute(1,2,0).cpu().numpy()
   
    plt.figure(figsize=(4,4))
    plt.imshow(img)
    plt.axis('off')
    plt.show()

def interpolate_images(seed1=42, seed2=123, steps=10, truncation=1.0, network_pkl="stylegan2-ada-pytorch/pretrained/ffhq.pkl"):
    print(f'Interpolating between seeds {seed1} and {seed2} with {steps} steps and truncation {truncation}')
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
   
    with dnnlib.util.open_url(network_pkl) as f:                              # Load the pretrained generator network
        G = legacy.load_network_pkl(f)('G_ema').to(device)
   
    # Generate latent vectors for the two seeds
    z1 = torch.from_numpy(np.random.RandomState(seed1).randn(1, G.z_dim)).to(device)
    z2 = torch.from_numpy(np.random.RandomState(seed2).randn(1, G.z_dim)).to(device)
   
    # Create interpolation latent vectors
    alphas = np.linspace(0, 1, steps)
    z_interp = ()
    for a in alphas:
        z_interp.append((1 - a) * z1 + a * z2)
    z_interp = torch.cat(z_interp, dim=0)
    label = None


    # Generate images for each interpolated latent vector
    with torch.no_grad():
        imgs = G(z_interp, label, truncation_psi=truncation, noise_mode="const")
   
    imgs = (imgs + 1) * (255/2)
    imgs = imgs.clamp(0,255).to(torch.uint8).cpu().numpy()
   
    plt.figure(figsize=(steps * 2, 2))                                          # Plot images in a row to visualize the interpolation
    for i in range(steps):
        plt.subplot(1, steps, i+1)
        img = np.transpose(imgs(i), (1,2,0))
        plt.imshow(img)
        plt.axis('off')
    plt.show()