def __init__(self, dlatent_size=512, num_channels=3, resolution=1024,
fmap_base=16 << 10, fmap_decay=1.0, fmap_min=1, fmap_max=512,
randomize_noise=True, architecture='skip', **_kwargs):
"""
Args:
dlatent_size: Disentangled latent (W) dimensionality.
num_channels: Number of output color channels.
resolution: Output resolution.
fmap_base: Overall multiplier for the number of feature maps.
fmap_decay: log2 feature map reduction when doubling the resolution.
fmap_min: Minimum number of feature maps in any layer.
fmap_max: Maximum number of feature maps in any layer.
randomize_noise: True = randomize noise inputs every time (non-deterministic),
False = read noise inputs from variables.
architecture: Architecture: 'orig', 'skip', 'resnet'.
# nonlinearity: Activation function: 'relu', 'lrelu', etc.
# resample_kernel: Low-pass filter to apply when resampling activations. None = no filtering.
# fused_modconv: Implement modulated_conv2d_layer() as a single fused op?
**_kwargs: Ignore unrecognized keyword args.):
"""
super(GSynthesis, self).__init__()
resolution_log2 = int(np.log2(resolution))
assert resolution == 2 ** resolution_log2 and resolution >= 4
assert architecture in ['orig', 'skip', 'resnet']
self.architecture = architecture
self.resolution_log2 = resolution_log2
self.randomize_noise = randomize_noise
def nf(stage):
return np.clip(int(fmap_base / (2.0 ** (stage * fmap_decay))), fmap_min, fmap_max)
# Early layers
self.init_block = InputBlock(dlatent_size=dlatent_size, num_channels=num_channels,
in_fmaps=nf(1), out_fmaps=nf(1), use_noise=randomize_noise)
# Main layers
blocks = [GSynthesisBlock(dlatent_size=dlatent_size, num_channels=num_channels, res=res,
in_fmaps=nf(res - 2), out_fmaps=nf(res - 1), use_noise=randomize_noise)
for res in range(3, resolution_log2 + 1)]
self.blocks = nn.ModuleList(blocks)
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)