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 = EqualizedConv2d(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 = EqualizedConv2d(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 __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 = EqualizedLinear(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 = EqualizedConv2d(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 __init__(self,
mbstd_group_size,
mbstd_num_features,
in_channels,
intermediate_channels,
gain,
use_wscale,
activation_layer,
resolution=4,
in_channels2=None,
output_features=1,
last_gain=1):
"""
:param mbstd_group_size:
:param mbstd_num_features:
:param in_channels:
:param intermediate_channels:
:param gain:
:param use_wscale:
:param activation_layer:
:param resolution:
:param in_channels2:
:param output_features:
:param last_gain:
"""
layers = []
if mbstd_group_size > 1:
layers.append(('stddev_layer',
StddevLayer(mbstd_group_size, mbstd_num_features)))
if in_channels2 is None:
in_channels2 = in_channels
layers.append(('conv',
EqualizedConv2d(in_channels + mbstd_num_features,
in_channels2,
kernel_size=3,
gain=gain,
use_wscale=use_wscale)))
layers.append(('act0', activation_layer))
layers.append(('view', View(-1)))
layers.append(('dense0',
EqualizedLinear(in_channels2 * resolution * resolution,
intermediate_channels,
gain=gain,
use_wscale=use_wscale)))
layers.append(('act1', activation_layer))
layers.append(('dense1',
EqualizedLinear(intermediate_channels,
output_features,
gain=last_gain,
use_wscale=use_wscale)))
super().__init__(OrderedDict(layers))
def __init__(self, in_channels, out_channels, gain, use_wscale,
activation_layer, blur_kernel):
super().__init__(
OrderedDict([
('conv0',
EqualizedConv2d(in_channels,
in_channels,
kernel_size=3,
gain=gain,
use_wscale=use_wscale)),
# out channels nf(res-1)
('act0', activation_layer),
('blur', BlurLayer(kernel=blur_kernel)),
('conv1_down',
EqualizedConv2d(in_channels,
out_channels,
kernel_size=3,
gain=gain,
use_wscale=use_wscale,
downscale=True)),
('act1', activation_layer)
]))
def __init__(self, resolution, num_channels=3, fmap_base=8192, fmap_decay=1.0, fmap_max=512,
nonlinearity='lrelu', use_wscale=True, mbstd_group_size=4, mbstd_num_features=1,
blur_filter=None, structure='linear', **kwargs):
"""
Discriminator used in the StyleGAN paper.
:param num_channels: Number of input color channels. Overridden based on dataset.
:param resolution: Input resolution. Overridden based on dataset.
# label_size=0, # Dimensionality of the labels, 0 if no labels. Overridden based on dataset.
:param fmap_base: Overall multiplier for the number of feature maps.
:param fmap_decay: log2 feature map reduction when doubling the resolution.
:param fmap_max: Maximum number of feature maps in any layer.
:param nonlinearity: Activation function: 'relu', 'lrelu'
:param use_wscale: Enable equalized learning rate?
:param mbstd_group_size: Group size for the mini_batch standard deviation layer, 0 = disable.
:param mbstd_num_features: Number of features for the mini_batch standard deviation layer.
:param blur_filter: Low-pass filter to apply when resampling activations. None = no filtering.
:param structure: 'fixed' = no progressive growing, 'linear' = human-readable
:param kwargs: Ignore unrecognized keyword args.
"""
super(Discriminator, self).__init__()
def nf(stage):
return min(int(fmap_base / (2.0 ** (stage * fmap_decay))), fmap_max)
self.mbstd_num_features = mbstd_num_features
self.mbstd_group_size = mbstd_group_size
self.structure = structure
# if blur_filter is None:
# blur_filter = [1, 2, 1]
resolution_log2 = int(np.log2(resolution))
assert resolution == 2 ** resolution_log2 and resolution >= 4
self.depth = resolution_log2 - 1
act, gain = {'relu': (torch.relu, np.sqrt(2)),
'lrelu': (nn.LeakyReLU(negative_slope=0.2), np.sqrt(2))}[nonlinearity]
# create the remaining layers
blocks = []
from_rgb = []
for res in range(resolution_log2, 2, -1):
# name = '{s}x{s}'.format(s=2 ** res)
blocks.append(DiscriminatorBlock(nf(res - 1), nf(res - 2),
gain=gain, use_wscale=use_wscale, activation_layer=act,
blur_kernel=blur_filter))
# create the fromRGB layers for various inputs:
from_rgb.append(EqualizedConv2d(num_channels, nf(res - 1), kernel_size=1,
gain=gain, use_wscale=use_wscale))
self.blocks = nn.ModuleList(blocks)
# Building the final block.
self.final_block = DiscriminatorTop(self.mbstd_group_size, self.mbstd_num_features,
in_channels=nf(2), intermediate_channels=nf(2),
gain=gain, use_wscale=use_wscale, activation_layer=act)
from_rgb.append(EqualizedConv2d(num_channels, nf(2), kernel_size=1,
gain=gain, use_wscale=use_wscale))
self.from_rgb = nn.ModuleList(from_rgb)
# register the temporary downSampler
self.temporaryDownsampler = nn.AvgPool2d(2)
def __init__(self, dlatent_size=512, num_channels=3, resolution=1024,
fmap_base=8192, fmap_decay=1.0, fmap_max=512,
use_styles=True, const_input_layer=True, use_noise=True, nonlinearity='lrelu',
use_wscale=True, use_pixel_norm=False, use_instance_norm=True, blur_filter=None,
structure='linear', **kwargs):
"""
Synthesis network used in the StyleGAN paper.
:param dlatent_size: Disentangled latent (W) dimensionality.
:param num_channels: Number of output color channels.
:param resolution: Output resolution.
:param fmap_base: Overall multiplier for the number of feature maps.
:param fmap_decay: log2 feature map reduction when doubling the resolution.
:param fmap_max: Maximum number of feature maps in any layer.
:param use_styles: Enable style inputs?
:param const_input_layer: First layer is a learned constant?
:param use_noise: Enable noise inputs?
# :param randomize_noise: True = randomize noise inputs every time (non-deterministic),
False = read noise inputs from variables.
:param nonlinearity: Activation function: 'relu', 'lrelu'
:param use_wscale: Enable equalized learning rate?
:param use_pixel_norm: Enable pixel_wise feature vector normalization?
:param use_instance_norm: Enable instance normalization?
:param blur_filter: Low-pass filter to apply when resampling activations. None = no filtering.
:param structure: 'fixed' = no progressive growing, 'linear' = human-readable
:param kwargs: Ignore unrecognized keyword args.
"""
super().__init__()
# if blur_filter is None:
# blur_filter = [1, 2, 1]
def nf(stage):
return min(int(fmap_base / (2.0 ** (stage * fmap_decay))), fmap_max)
self.structure = structure
resolution_log2 = int(np.log2(resolution))
assert resolution == 2 ** resolution_log2 and resolution >= 4
self.depth = resolution_log2 - 1
self.num_layers = resolution_log2 * 2 - 2
self.num_styles = self.num_layers if use_styles else 1
act, gain = {'relu': (torch.relu, np.sqrt(2)),
'lrelu': (nn.LeakyReLU(negative_slope=0.2), np.sqrt(2))}[nonlinearity]
# Early layers.
self.init_block = InputBlock(nf(1), dlatent_size, const_input_layer, gain, use_wscale,
use_noise, use_pixel_norm, use_instance_norm, use_styles, act)
# create the ToRGB layers for various outputs
rgb_converters = [EqualizedConv2d(nf(1), num_channels, 1, gain=1, use_wscale=use_wscale)]
# Building blocks for remaining layers.
blocks = []
for res in range(3, resolution_log2 + 1):
last_channels = nf(res - 2)
channels = nf(res - 1)
# name = '{s}x{s}'.format(s=2 ** res)
blocks.append(GSynthesisBlock(last_channels, channels, blur_filter, dlatent_size, gain, use_wscale,
use_noise, use_pixel_norm, use_instance_norm, use_styles, act))
rgb_converters.append(EqualizedConv2d(channels, num_channels, 1, gain=1, use_wscale=use_wscale))
self.blocks = nn.ModuleList(blocks)
self.to_rgb = nn.ModuleList(rgb_converters)
# register the temporary upsampler
self.temporaryUpsampler = lambda x: interpolate(x, scale_factor=2)