S3Diff / basicsr /archs /hifacegan_arch.py
zhangap's picture
Upload 213 files
36d9761 verified
raw
history blame
8.93 kB
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from basicsr.utils.registry import ARCH_REGISTRY
from .hifacegan_util import BaseNetwork, LIPEncoder, SPADEResnetBlock, get_nonspade_norm_layer
class SPADEGenerator(BaseNetwork):
"""Generator with SPADEResBlock"""
def __init__(self,
num_in_ch=3,
num_feat=64,
use_vae=False,
z_dim=256,
crop_size=512,
norm_g='spectralspadesyncbatch3x3',
is_train=True,
init_train_phase=3): # progressive training disabled
super().__init__()
self.nf = num_feat
self.input_nc = num_in_ch
self.is_train = is_train
self.train_phase = init_train_phase
self.scale_ratio = 5 # hardcoded now
self.sw = crop_size // (2**self.scale_ratio)
self.sh = self.sw # 20210519: By default use square image, aspect_ratio = 1.0
if use_vae:
# In case of VAE, we will sample from random z vector
self.fc = nn.Linear(z_dim, 16 * self.nf * self.sw * self.sh)
else:
# Otherwise, we make the network deterministic by starting with
# downsampled segmentation map instead of random z
self.fc = nn.Conv2d(num_in_ch, 16 * self.nf, 3, padding=1)
self.head_0 = SPADEResnetBlock(16 * self.nf, 16 * self.nf, norm_g)
self.g_middle_0 = SPADEResnetBlock(16 * self.nf, 16 * self.nf, norm_g)
self.g_middle_1 = SPADEResnetBlock(16 * self.nf, 16 * self.nf, norm_g)
self.ups = nn.ModuleList([
SPADEResnetBlock(16 * self.nf, 8 * self.nf, norm_g),
SPADEResnetBlock(8 * self.nf, 4 * self.nf, norm_g),
SPADEResnetBlock(4 * self.nf, 2 * self.nf, norm_g),
SPADEResnetBlock(2 * self.nf, 1 * self.nf, norm_g)
])
self.to_rgbs = nn.ModuleList([
nn.Conv2d(8 * self.nf, 3, 3, padding=1),
nn.Conv2d(4 * self.nf, 3, 3, padding=1),
nn.Conv2d(2 * self.nf, 3, 3, padding=1),
nn.Conv2d(1 * self.nf, 3, 3, padding=1)
])
self.up = nn.Upsample(scale_factor=2)
def encode(self, input_tensor):
"""
Encode input_tensor into feature maps, can be overridden in derived classes
Default: nearest downsampling of 2**5 = 32 times
"""
h, w = input_tensor.size()[-2:]
sh, sw = h // 2**self.scale_ratio, w // 2**self.scale_ratio
x = F.interpolate(input_tensor, size=(sh, sw))
return self.fc(x)
def forward(self, x):
# In oroginal SPADE, seg means a segmentation map, but here we use x instead.
seg = x
x = self.encode(x)
x = self.head_0(x, seg)
x = self.up(x)
x = self.g_middle_0(x, seg)
x = self.g_middle_1(x, seg)
if self.is_train:
phase = self.train_phase + 1
else:
phase = len(self.to_rgbs)
for i in range(phase):
x = self.up(x)
x = self.ups[i](x, seg)
x = self.to_rgbs[phase - 1](F.leaky_relu(x, 2e-1))
x = torch.tanh(x)
return x
def mixed_guidance_forward(self, input_x, seg=None, n=0, mode='progressive'):
"""
A helper class for subspace visualization. Input and seg are different images.
For the first n levels (including encoder) we use input, for the rest we use seg.
If mode = 'progressive', the output's like: AAABBB
If mode = 'one_plug', the output's like: AAABAA
If mode = 'one_ablate', the output's like: BBBABB
"""
if seg is None:
return self.forward(input_x)
if self.is_train:
phase = self.train_phase + 1
else:
phase = len(self.to_rgbs)
if mode == 'progressive':
n = max(min(n, 4 + phase), 0)
guide_list = [input_x] * n + [seg] * (4 + phase - n)
elif mode == 'one_plug':
n = max(min(n, 4 + phase - 1), 0)
guide_list = [seg] * (4 + phase)
guide_list[n] = input_x
elif mode == 'one_ablate':
if n > 3 + phase:
return self.forward(input_x)
guide_list = [input_x] * (4 + phase)
guide_list[n] = seg
x = self.encode(guide_list[0])
x = self.head_0(x, guide_list[1])
x = self.up(x)
x = self.g_middle_0(x, guide_list[2])
x = self.g_middle_1(x, guide_list[3])
for i in range(phase):
x = self.up(x)
x = self.ups[i](x, guide_list[4 + i])
x = self.to_rgbs[phase - 1](F.leaky_relu(x, 2e-1))
x = torch.tanh(x)
return x
@ARCH_REGISTRY.register()
class HiFaceGAN(SPADEGenerator):
"""
HiFaceGAN: SPADEGenerator with a learnable feature encoder
Current encoder design: LIPEncoder
"""
def __init__(self,
num_in_ch=3,
num_feat=64,
use_vae=False,
z_dim=256,
crop_size=512,
norm_g='spectralspadesyncbatch3x3',
is_train=True,
init_train_phase=3):
super().__init__(num_in_ch, num_feat, use_vae, z_dim, crop_size, norm_g, is_train, init_train_phase)
self.lip_encoder = LIPEncoder(num_in_ch, num_feat, self.sw, self.sh, self.scale_ratio)
def encode(self, input_tensor):
return self.lip_encoder(input_tensor)
@ARCH_REGISTRY.register()
class HiFaceGANDiscriminator(BaseNetwork):
"""
Inspired by pix2pixHD multiscale discriminator.
Args:
num_in_ch (int): Channel number of inputs. Default: 3.
num_out_ch (int): Channel number of outputs. Default: 3.
conditional_d (bool): Whether use conditional discriminator.
Default: True.
num_d (int): Number of Multiscale discriminators. Default: 3.
n_layers_d (int): Number of downsample layers in each D. Default: 4.
num_feat (int): Channel number of base intermediate features.
Default: 64.
norm_d (str): String to determine normalization layers in D.
Choices: [spectral][instance/batch/syncbatch]
Default: 'spectralinstance'.
keep_features (bool): Keep intermediate features for matching loss, etc.
Default: True.
"""
def __init__(self,
num_in_ch=3,
num_out_ch=3,
conditional_d=True,
num_d=2,
n_layers_d=4,
num_feat=64,
norm_d='spectralinstance',
keep_features=True):
super().__init__()
self.num_d = num_d
input_nc = num_in_ch
if conditional_d:
input_nc += num_out_ch
for i in range(num_d):
subnet_d = NLayerDiscriminator(input_nc, n_layers_d, num_feat, norm_d, keep_features)
self.add_module(f'discriminator_{i}', subnet_d)
def downsample(self, x):
return F.avg_pool2d(x, kernel_size=3, stride=2, padding=[1, 1], count_include_pad=False)
# Returns list of lists of discriminator outputs.
# The final result is of size opt.num_d x opt.n_layers_D
def forward(self, x):
result = []
for _, _net_d in self.named_children():
out = _net_d(x)
result.append(out)
x = self.downsample(x)
return result
class NLayerDiscriminator(BaseNetwork):
"""Defines the PatchGAN discriminator with the specified arguments."""
def __init__(self, input_nc, n_layers_d, num_feat, norm_d, keep_features):
super().__init__()
kw = 4
padw = int(np.ceil((kw - 1.0) / 2))
nf = num_feat
self.keep_features = keep_features
norm_layer = get_nonspade_norm_layer(norm_d)
sequence = [[nn.Conv2d(input_nc, nf, kernel_size=kw, stride=2, padding=padw), nn.LeakyReLU(0.2, False)]]
for n in range(1, n_layers_d):
nf_prev = nf
nf = min(nf * 2, 512)
stride = 1 if n == n_layers_d - 1 else 2
sequence += [[
norm_layer(nn.Conv2d(nf_prev, nf, kernel_size=kw, stride=stride, padding=padw)),
nn.LeakyReLU(0.2, False)
]]
sequence += [[nn.Conv2d(nf, 1, kernel_size=kw, stride=1, padding=padw)]]
# We divide the layers into groups to extract intermediate layer outputs
for n in range(len(sequence)):
self.add_module('model' + str(n), nn.Sequential(*sequence[n]))
def forward(self, x):
results = [x]
for submodel in self.children():
intermediate_output = submodel(results[-1])
results.append(intermediate_output)
if self.keep_features:
return results[1:]
else:
return results[-1]