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, latent_size=512, dlatent_size=512, dlatent_broadcast=None,
mapping_layers=8, mapping_fmaps=512, mapping_lrmul=0.01, mapping_nonlinearity='lrelu',
use_wscale=True, normalize_latents=True, **kwargs):
"""
Mapping network used in the StyleGAN paper.
:param latent_size: Latent vector(Z) dimensionality.
# :param label_size: Label dimensionality, 0 if no labels.
:param dlatent_size: Disentangled latent (W) dimensionality.
:param dlatent_broadcast: Output disentangled latent (W) as [minibatch, dlatent_size]
or [minibatch, dlatent_broadcast, dlatent_size].
:param mapping_layers: Number of mapping layers.
:param mapping_fmaps: Number of activations in the mapping layers.
:param mapping_lrmul: Learning rate multiplier for the mapping layers.
:param mapping_nonlinearity: Activation function: 'relu', 'lrelu'.
:param use_wscale: Enable equalized learning rate?
:param normalize_latents: Normalize latent vectors (Z) before feeding them to the mapping layers?
:param kwargs: Ignore unrecognized keyword args.
"""
super().__init__()
self.latent_size = latent_size
self.mapping_fmaps = mapping_fmaps
self.dlatent_size = dlatent_size
self.dlatent_broadcast = dlatent_broadcast
# Activation function.
act, gain = {'relu': (torch.relu, np.sqrt(2)),
'lrelu': (nn.LeakyReLU(negative_slope=0.2), np.sqrt(2))}[mapping_nonlinearity]
# Embed labels and concatenate them with latents.
# TODO
layers = []
# Normalize latents.
if normalize_latents:
layers.append(('pixel_norm', PixelNormLayer()))
# Mapping layers. (apply_bias?)
layers.append(('dense0', EqualizedLinear(self.latent_size, self.mapping_fmaps,
gain=gain, lrmul=mapping_lrmul, use_wscale=use_wscale)))
layers.append(('dense0_act', act))
for layer_idx in range(1, mapping_layers):
fmaps_in = self.mapping_fmaps
fmaps_out = self.dlatent_size if layer_idx == mapping_layers - 1 else self.mapping_fmaps
layers.append(
('dense{:d}'.format(layer_idx),
EqualizedLinear(fmaps_in, fmaps_out, gain=gain, lrmul=mapping_lrmul, use_wscale=use_wscale)))
layers.append(('dense{:d}_act'.format(layer_idx), act))
# Output.
self.map = nn.Sequential(OrderedDict(layers))
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,
latent_size=512,
label_size=0,
dlatent_size=512,
dlatent_broadcast=None,
mapping_layers=8,
mapping_fmaps=512,
mapping_lrmul=0.01,
mapping_nonlinearity='lrelu',
normalize_latents=True,
**_kwargs):
"""
Mapping network used in the StyleGAN paper.
:param latent_size: Latent vector(Z) dimensionality.
:param label_size: Label dimensionality, 0 if no labels.
:param dlatent_size: Disentangled latent (W) dimensionality.
:param dlatent_broadcast: Output disentangled latent (W) as [minibatch, dlatent_size]
or [minibatch, dlatent_broadcast, dlatent_size].
:param mapping_layers: Number of mapping layers.
:param mapping_fmaps: Number of activations in the mapping layers.
:param mapping_lrmul: Learning rate multiplier for the mapping layers.
:param mapping_nonlinearity: Activation function: 'relu', 'lrelu'.
:param normalize_latents: Normalize latent vectors (Z) before feeding them to the mapping layers?
:param _kwargs: Ignore unrecognized keyword args.
"""
super(GMapping, self).__init__()
self.latent_size = latent_size
self.mapping_fmaps = mapping_fmaps
self.dlatent_size = dlatent_size
self.dlatent_broadcast = dlatent_broadcast
self.normalize_latents = normalize_latents
# Embed labels and concatenate them with latents.
if label_size:
# TODO
pass
layers = []
for layer_idx in range(0, mapping_layers):
fmaps_in = self.latent_size if layer_idx == 0 else self.mapping_fmaps
fmaps_out = self.dlatent_size if layer_idx == mapping_layers - 1 else self.mapping_fmaps
layers.append(('dense_%d' % layer_idx,
EqualizedLinear(in_dim=fmaps_in,
out_dim=fmaps_out,
lrmul=mapping_lrmul,
activation=mapping_nonlinearity)))
# Output
self.map = nn.Sequential(OrderedDict(layers))