def decoder_b_fast(self):
""" DeLight Fast Decoder B(new face) Network """
input_ = Input(shape=(4, 4, 1024))
decoder_b_complexity = 512
mask_complexity = 128
var_xy = input_
var_xy = UpscaleBlock(512, scale_factor=self.upscale_ratio)(var_xy)
var_x = var_xy
var_x = Upscale2xBlock(decoder_b_complexity, fast=True)(var_x)
var_x = Upscale2xBlock(decoder_b_complexity // 2, fast=True)(var_x)
var_x = Upscale2xBlock(decoder_b_complexity // 4, fast=True)(var_x)
var_x = Upscale2xBlock(decoder_b_complexity // 8, fast=True)(var_x)
var_x = Conv2DOutput(3, 5, name="face_out")(var_x)
outputs = [var_x]
if self.config.get("learn_mask", False):
var_y = var_xy # mask decoder
var_y = Upscale2xBlock(mask_complexity, fast=False)(var_y)
var_y = Upscale2xBlock(mask_complexity // 2, fast=False)(var_y)
var_y = Upscale2xBlock(mask_complexity // 4, fast=False)(var_y)
var_y = Upscale2xBlock(mask_complexity // 8, fast=False)(var_y)
var_y = Conv2DOutput(1, 5, name="mask_out")(var_y)
outputs.append(var_y)
return KerasModel([input_], outputs=outputs, name="decoder_b_fast")
def decoder_a(self):
""" DeLight Decoder A(old face) Network """
input_ = Input(shape=(4, 4, 1024))
decoder_a_complexity = 256
mask_complexity = 128
var_xy = input_
var_xy = UpSampling2D(self.upscale_ratio,
interpolation='bilinear')(var_xy)
var_x = var_xy
var_x = Upscale2xBlock(decoder_a_complexity, fast=False)(var_x)
var_x = Upscale2xBlock(decoder_a_complexity // 2, fast=False)(var_x)
var_x = Upscale2xBlock(decoder_a_complexity // 4, fast=False)(var_x)
var_x = Upscale2xBlock(decoder_a_complexity // 8, fast=False)(var_x)
var_x = Conv2DOutput(3, 5, name="face_out")(var_x)
outputs = [var_x]
if self.config.get("learn_mask", False):
var_y = var_xy # mask decoder
var_y = Upscale2xBlock(mask_complexity, fast=False)(var_y)
var_y = Upscale2xBlock(mask_complexity // 2, fast=False)(var_y)
var_y = Upscale2xBlock(mask_complexity // 4, fast=False)(var_y)
var_y = Upscale2xBlock(mask_complexity // 8, fast=False)(var_y)
var_y = Conv2DOutput(1, 5, name="mask_out")(var_y)
outputs.append(var_y)
return KerasModel([input_], outputs=outputs, name="decoder_a")
def decoder(self, side):
""" Decoder Network """
input_ = Input(shape=(8, 8, 512))
var_x = input_
if self._output_size == 256:
var_x = UpscaleBlock(1024, activation=None)(var_x)
var_x = LeakyReLU(alpha=0.2)(var_x)
var_x = ResidualBlock(1024, kernel_initializer=self.kernel_initializer)(var_x)
var_x = UpscaleBlock(512, activation=None)(var_x)
var_x = LeakyReLU(alpha=0.2)(var_x)
var_x = ResidualBlock(512, kernel_initializer=self.kernel_initializer)(var_x)
var_x = UpscaleBlock(256, activation=None)(var_x)
var_x = LeakyReLU(alpha=0.2)(var_x)
var_x = ResidualBlock(256, kernel_initializer=self.kernel_initializer)(var_x)
var_x = UpscaleBlock(128, activation=None)(var_x)
var_x = LeakyReLU(alpha=0.2)(var_x)
var_x = ResidualBlock(128, kernel_initializer=self.kernel_initializer)(var_x)
var_x = UpscaleBlock(64, activation="leakyrelu")(var_x)
var_x = Conv2DOutput(3, 5, name=f"face_out_{side}")(var_x)
outputs = [var_x]
if self.config.get("learn_mask", False):
var_y = input_
if self._output_size == 256:
var_y = UpscaleBlock(1024, activation="leakyrelu")(var_y)
var_y = UpscaleBlock(512, activation="leakyrelu")(var_y)
var_y = UpscaleBlock(256, activation="leakyrelu")(var_y)
var_y = UpscaleBlock(128, activation="leakyrelu")(var_y)
var_y = UpscaleBlock(64, activation="leakyrelu")(var_y)
var_y = Conv2DOutput(1, 5, name=f"mask_out_{side}")(var_y)
outputs.append(var_y)
return KerasModel([input_], outputs=outputs, name=f"decoder_{side}")
def decoder_a(self):
""" Decoder for side A """
kwargs = dict(kernel_size=5, kernel_initializer=self.kernel_initializer)
decoder_complexity = 320 if self.low_mem else self.config["complexity_decoder_a"]
dense_dim = 384 if self.low_mem else 512
decoder_shape = self.input_shape[0] // 16
input_ = Input(shape=(decoder_shape, decoder_shape, dense_dim))
var_x = input_
var_x = UpscaleBlock(decoder_complexity, activation="leakyrelu", **kwargs)(var_x)
var_x = SpatialDropout2D(0.25)(var_x)
var_x = UpscaleBlock(decoder_complexity, activation="leakyrelu", **kwargs)(var_x)
if self.low_mem:
var_x = SpatialDropout2D(0.15)(var_x)
else:
var_x = SpatialDropout2D(0.25)(var_x)
var_x = UpscaleBlock(decoder_complexity // 2, activation="leakyrelu", **kwargs)(var_x)
var_x = UpscaleBlock(decoder_complexity // 4, activation="leakyrelu", **kwargs)(var_x)
var_x = Conv2DOutput(3, 5, name="face_out_a")(var_x)
outputs = [var_x]
if self.config.get("learn_mask", False):
var_y = input_
var_y = UpscaleBlock(decoder_complexity, activation="leakyrelu")(var_y)
var_y = UpscaleBlock(decoder_complexity, activation="leakyrelu")(var_y)
var_y = UpscaleBlock(decoder_complexity // 2, activation="leakyrelu")(var_y)
var_y = UpscaleBlock(decoder_complexity // 4, activation="leakyrelu")(var_y)
var_y = Conv2DOutput(1, 5, name="mask_out_a")(var_y)
outputs.append(var_y)
return KerasModel(input_, outputs=outputs, name="decoder_a")
def decoder(self, side):
""" Decoder Network """
kwargs = dict(kernel_initializer=self.kernel_initializer)
decoder_shape = self.input_shape[0] // 8
input_ = Input(shape=(decoder_shape, decoder_shape, 512))
var_x = input_
var_x = UpscaleBlock(512, activation=None, **kwargs)(var_x)
var_x = LeakyReLU(alpha=0.2)(var_x)
var_x = ResidualBlock(512, **kwargs)(var_x)
var_x = UpscaleBlock(256, activation=None, **kwargs)(var_x)
var_x = LeakyReLU(alpha=0.2)(var_x)
var_x = ResidualBlock(256, **kwargs)(var_x)
var_x = UpscaleBlock(self.input_shape[0], activation=None, **kwargs)(var_x)
var_x = LeakyReLU(alpha=0.2)(var_x)
var_x = ResidualBlock(self.input_shape[0], **kwargs)(var_x)
var_x = Conv2DOutput(3, 5, name=f"face_out_{side}")(var_x)
outputs = [var_x]
if self.config.get("learn_mask", False):
var_y = input_
var_y = UpscaleBlock(512, activation="leakyrelu")(var_y)
var_y = UpscaleBlock(256, activation="leakyrelu")(var_y)
var_y = UpscaleBlock(self.input_shape[0], activation="leakyrelu")(var_y)
var_y = Conv2DOutput(1, 5, name=f"mask_out_{side}")(var_y)
outputs.append(var_y)
return KerasModel(input_, outputs=outputs, name=f"decoder_{side}")
def decoder(self, side):
""" Decoder Network """
kwargs = dict(kernel_initializer=self.kernel_initializer)
decoder_shape = self.input_shape[0] // 8
input_ = Input(shape=(decoder_shape, decoder_shape, 512))
var_x = input_
var_x = UpscaleBlock(512, res_block_follows=True, **kwargs)(var_x)
var_x = ResidualBlock(512, **kwargs)(var_x)
var_x = UpscaleBlock(256, res_block_follows=True, **kwargs)(var_x)
var_x = ResidualBlock(256, **kwargs)(var_x)
var_x = UpscaleBlock(self.input_shape[0],
res_block_follows=True,
**kwargs)(var_x)
var_x = ResidualBlock(self.input_shape[0], **kwargs)(var_x)
var_x = Conv2DOutput(3, 5, name="face_out_{}".format(side))(var_x)
outputs = [var_x]
if self.config.get("learn_mask", False):
var_y = input_
var_y = UpscaleBlock(512)(var_y)
var_y = UpscaleBlock(256)(var_y)
var_y = UpscaleBlock(self.input_shape[0])(var_y)
var_y = Conv2DOutput(1, 5, name="mask_out_{}".format(side))(var_y)
outputs.append(var_y)
return KerasModel(input_,
outputs=outputs,
name="decoder_{}".format(side))
def decoder(self, side):
""" Decoder Network """
input_ = Input(shape=(8, 8, 256))
var_x = input_
var_x = UpscaleBlock(512)(var_x)
var_x = UpscaleBlock(256)(var_x)
var_x = UpscaleBlock(128)(var_x)
var_x = Conv2DOutput(3,
5,
activation="sigmoid",
name="face_out_{}".format(side))(var_x)
outputs = [var_x]
if self.config.get("learn_mask", False):
var_y = input_
var_y = UpscaleBlock(512)(var_y)
var_y = UpscaleBlock(256)(var_y)
var_y = UpscaleBlock(128)(var_y)
var_y = Conv2DOutput(1,
5,
activation="sigmoid",
name="mask_out_{}".format(side))(var_y)
outputs.append(var_y)
return KerasModel(input_,
outputs=outputs,
name="decoder_{}".format(side))
def decoder(self, side):
""" Decoder Network """
input_ = Input(shape=(8, 8, 512))
var_x = input_
if self._output_size == 256:
var_x = UpscaleBlock(1024, res_block_follows=True)(var_x)
var_x = ResidualBlock(
1024, kernel_initializer=self.kernel_initializer)(var_x)
var_x = UpscaleBlock(512, res_block_follows=True)(var_x)
var_x = ResidualBlock(
512, kernel_initializer=self.kernel_initializer)(var_x)
var_x = UpscaleBlock(256, res_block_follows=True)(var_x)
var_x = ResidualBlock(
256, kernel_initializer=self.kernel_initializer)(var_x)
var_x = UpscaleBlock(128, res_block_follows=True)(var_x)
var_x = ResidualBlock(
128, kernel_initializer=self.kernel_initializer)(var_x)
var_x = UpscaleBlock(64)(var_x)
var_x = Conv2DOutput(3, 5, name="face_out_{}".format(side))(var_x)
outputs = [var_x]
if self.config.get("learn_mask", False):
var_y = input_
if self._output_size == 256:
var_y = UpscaleBlock(1024)(var_y)
var_y = UpscaleBlock(512)(var_y)
var_y = UpscaleBlock(256)(var_y)
var_y = UpscaleBlock(128)(var_y)
var_y = UpscaleBlock(64)(var_y)
var_y = Conv2DOutput(1, 5, name="mask_out_{}".format(side))(var_y)
outputs.append(var_y)
return KerasModel([input_],
outputs=outputs,
name="decoder_{}".format(side))
def decoder(self, side):
""" The original Faceswap Decoder Network.
The decoders for the original model have separate weights for each side "A" and "B", so two
instances are created in :func:`build_model`, one for each side.
Parameters
----------
side: str
Either `"a` or `"b"`. This is used for naming the decoder model.
Returns
-------
:class:`keras.models.Model`
The Keras decoder model. This will be called twice, once for each side.
"""
input_ = Input(shape=(8, 8, 512))
var_x = input_
var_x = UpscaleBlock(256, activation="leakyrelu")(var_x)
var_x = UpscaleBlock(128, activation="leakyrelu")(var_x)
var_x = UpscaleBlock(64, activation="leakyrelu")(var_x)
var_x = Conv2DOutput(3, 5, name="face_out_{}".format(side))(var_x)
outputs = [var_x]
if self.learn_mask:
var_y = input_
var_y = UpscaleBlock(256, activation="leakyrelu")(var_y)
var_y = UpscaleBlock(128, activation="leakyrelu")(var_y)
var_y = UpscaleBlock(64, activation="leakyrelu")(var_y)
var_y = Conv2DOutput(1, 5, name="mask_out_{}".format(side))(var_y)
outputs.append(var_y)
return KerasModel(input_,
outputs=outputs,
name="decoder_{}".format(side))
def decoder_b(self):
""" RealFace Decoder Network """
input_filters = self.config["complexity_encoder"] * 2**(
self.downscalers_no - 1)
input_width = self.config["input_size"] // self._downscale_ratio
input_ = Input(shape=(input_width, input_width, input_filters))
var_xy = input_
var_xy = Dense(self.config["dense_nodes"])(Flatten()(var_xy))
var_xy = Dense(self.dense_width * self.dense_width *
self.dense_filters)(var_xy)
var_xy = Reshape(
(self.dense_width, self.dense_width, self.dense_filters))(var_xy)
var_xy = UpscaleBlock(self.dense_filters, activation=None)(var_xy)
var_x = var_xy
var_x = LeakyReLU(alpha=0.2)(var_x)
var_x = ResidualBlock(self.dense_filters, use_bias=False)(var_x)
decoder_b_complexity = self.config["complexity_decoder"]
for idx in range(self.upscalers_no - 2):
var_x = UpscaleBlock(decoder_b_complexity // 2**idx,
activation=None)(var_x)
var_x = LeakyReLU(alpha=0.2)(var_x)
var_x = ResidualBlock(decoder_b_complexity // 2**idx,
use_bias=False)(var_x)
var_x = ResidualBlock(decoder_b_complexity // 2**idx,
use_bias=True)(var_x)
var_x = UpscaleBlock(decoder_b_complexity // 2**(idx + 1),
activation="leakyrelu")(var_x)
var_x = Conv2DOutput(3, 5, name="face_out_b")(var_x)
outputs = [var_x]
if self.config.get("learn_mask", False):
var_y = var_xy
var_y = LeakyReLU(alpha=0.1)(var_y)
mask_b_complexity = 384
for idx in range(self.upscalers_no - 2):
var_y = UpscaleBlock(mask_b_complexity // 2**idx,
activation="leakyrelu")(var_y)
var_y = UpscaleBlock(mask_b_complexity // 2**(idx + 1),
activation="leakyrelu")(var_y)
var_y = Conv2DOutput(1, 5, name="mask_out_b")(var_y)
outputs += [var_y]
return KerasModel(input_, outputs=outputs, name="decoder_b")
def decoder_b(self):
""" Decoder for side B """
kwargs = dict(kernel_size=5,
kernel_initializer=self.kernel_initializer)
dense_dim = 384 if self.low_mem else self.config["complexity_decoder_b"]
decoder_complexity = 384 if self.low_mem else 512
decoder_shape = self.input_shape[0] // 16
input_ = Input(shape=(decoder_shape, decoder_shape, dense_dim))
var_x = input_
if self.low_mem:
var_x = UpscaleBlock(decoder_complexity, **kwargs)(var_x)
var_x = UpscaleBlock(decoder_complexity // 2, **kwargs)(var_x)
var_x = UpscaleBlock(decoder_complexity // 4, **kwargs)(var_x)
var_x = UpscaleBlock(decoder_complexity // 8, **kwargs)(var_x)
else:
var_x = UpscaleBlock(decoder_complexity,
res_block_follows=True,
**kwargs)(var_x)
var_x = ResidualBlock(
decoder_complexity,
kernel_initializer=self.kernel_initializer)(var_x)
var_x = UpscaleBlock(decoder_complexity,
res_block_follows=True,
**kwargs)(var_x)
var_x = ResidualBlock(
decoder_complexity,
kernel_initializer=self.kernel_initializer)(var_x)
var_x = UpscaleBlock(decoder_complexity // 2,
res_block_follows=True,
**kwargs)(var_x)
var_x = ResidualBlock(
decoder_complexity // 2,
kernel_initializer=self.kernel_initializer)(var_x)
var_x = UpscaleBlock(decoder_complexity // 4, **kwargs)(var_x)
var_x = Conv2DOutput(3, 5, name="face_out_b")(var_x)
outputs = [var_x]
if self.config.get("learn_mask", False):
var_y = input_
var_y = UpscaleBlock(decoder_complexity)(var_y)
if not self.low_mem:
var_y = UpscaleBlock(decoder_complexity)(var_y)
var_y = UpscaleBlock(decoder_complexity // 2)(var_y)
var_y = UpscaleBlock(decoder_complexity // 4)(var_y)
if self.low_mem:
var_y = UpscaleBlock(decoder_complexity // 8)(var_y)
var_y = Conv2DOutput(1, 5, name="mask_out_b")(var_y)
outputs.append(var_y)
return KerasModel(input_, outputs=outputs, name="decoder_b")
def decoder(self, side, input_shape):
""" DFL SAE Decoder Network"""
input_ = Input(shape=input_shape)
outputs = []
dims = self.input_shape[-1] * self.decoder_dim
var_x = input_
var_x1 = UpscaleBlock(dims * 8, activation=None)(var_x)
var_x1 = LeakyReLU(alpha=0.2)(var_x1)
var_x1 = ResidualBlock(dims * 8)(var_x1)
var_x1 = ResidualBlock(dims * 8)(var_x1)
if self.multiscale_count >= 3:
outputs.append(
Conv2DOutput(3, 5, name="face_out_32_{}".format(side))(var_x1))
var_x2 = UpscaleBlock(dims * 4, activation=None)(var_x1)
var_x2 = LeakyReLU(alpha=0.2)(var_x2)
var_x2 = ResidualBlock(dims * 4)(var_x2)
var_x2 = ResidualBlock(dims * 4)(var_x2)
if self.multiscale_count >= 2:
outputs.append(
Conv2DOutput(3, 5, name="face_out_64_{}".format(side))(var_x2))
var_x3 = UpscaleBlock(dims * 2, activation=None)(var_x2)
var_x3 = LeakyReLU(alpha=0.2)(var_x3)
var_x3 = ResidualBlock(dims * 2)(var_x3)
var_x3 = ResidualBlock(dims * 2)(var_x3)
outputs.append(
Conv2DOutput(3, 5, name="face_out_128_{}".format(side))(var_x3))
if self.use_mask:
var_y = input_
var_y = UpscaleBlock(self.decoder_dim * 8,
activation="leakyrelu")(var_y)
var_y = UpscaleBlock(self.decoder_dim * 4,
activation="leakyrelu")(var_y)
var_y = UpscaleBlock(self.decoder_dim * 2,
activation="leakyrelu")(var_y)
var_y = Conv2DOutput(1, 5, name="mask_out_{}".format(side))(var_y)
outputs.append(var_y)
return KerasModel(input_,
outputs=outputs,
name="decoder_{}".format(side))
def decoder(self, side):
""" DFL H128 Decoder """
input_ = Input(shape=(16, 16, self.encoder_dim))
var_x = input_
var_x = UpscaleBlock(self.encoder_dim)(var_x)
var_x = UpscaleBlock(self.encoder_dim // 2)(var_x)
var_x = UpscaleBlock(self.encoder_dim // 4)(var_x)
var_x = Conv2DOutput(3, 5, name="face_out_{}".format(side))(var_x)
outputs = [var_x]
if self.config.get("learn_mask", False):
var_y = input_
var_y = UpscaleBlock(self.encoder_dim)(var_y)
var_y = UpscaleBlock(self.encoder_dim // 2)(var_y)
var_y = UpscaleBlock(self.encoder_dim // 4)(var_y)
var_y = Conv2DOutput(1, 5, name="mask_out_{}".format(side))(var_y)
outputs.append(var_y)
return KerasModel(input_, outputs=outputs, name="decoder_{}".format(side))
def decoder_a(self):
""" RealFace Decoder (A) Network """
input_filters = self.config["complexity_encoder"] * 2**(
self.downscalers_no - 1)
input_width = self.config["input_size"] // self._downscale_ratio
input_ = Input(shape=(input_width, input_width, input_filters))
var_xy = input_
dense_nodes = int(self.config["dense_nodes"] / 1.5)
dense_filters = int(self.dense_filters / 1.5)
var_xy = Dense(dense_nodes)(Flatten()(var_xy))
var_xy = Dense(self.dense_width * self.dense_width *
dense_filters)(var_xy)
var_xy = Reshape(
(self.dense_width, self.dense_width, dense_filters))(var_xy)
var_xy = UpscaleBlock(dense_filters)(var_xy)
var_x = var_xy
var_x = ResidualBlock(dense_filters, use_bias=False)(var_x)
decoder_a_complexity = int(self.config["complexity_decoder"] / 1.5)
for idx in range(self.upscalers_no - 2):
var_x = UpscaleBlock(decoder_a_complexity // 2**idx)(var_x)
var_x = UpscaleBlock(decoder_a_complexity // 2**(idx + 1))(var_x)
var_x = Conv2DOutput(3, 5, name="face_out_a")(var_x)
outputs = [var_x]
if self.config.get("learn_mask", False):
var_y = var_xy
mask_a_complexity = 384
for idx in range(self.upscalers_no - 2):
var_y = UpscaleBlock(mask_a_complexity // 2**idx)(var_y)
var_y = UpscaleBlock(mask_a_complexity // 2**(idx + 1))(var_y)
var_y = Conv2DOutput(1, 5, name="mask_out_a")(var_y)
outputs += [var_y]
return KerasModel(input_, outputs=outputs, name="decoder_a")
def __call__(self):
""" Decoder Network.
Returns
-------
:class:`keras.models.Model`
The Decoder model
"""
inputs = Input(shape=self._input_shape)
var_x = inputs
var_x = self._reshape_for_output(var_x)
if self._config["learn_mask"]:
var_y = inputs
var_y = self._reshape_for_output(var_y)
# De-convolve
upscales = int(
np.log2(self._config["output_size"] / K.int_shape(var_x)[1]))
filters = _get_curve(self._config["dec_max_filters"],
self._config["dec_min_filters"], upscales,
self._config["dec_filter_slope"])
for idx, filts in enumerate(filters):
skip_res = idx == len(
filters) - 1 and self._config["dec_skip_last_residual"]
var_x = self._upscale_block(var_x, filts, skip_residual=skip_res)
if self._config["learn_mask"]:
var_y = self._upscale_block(var_y, filts, is_mask=True)
outputs = [
Conv2DOutput(3, self._config["dec_output_kernel"],
name="face_out")(var_x)
]
if self._config["learn_mask"]:
outputs.append(
Conv2DOutput(1,
self._config["dec_output_kernel"],
name="mask_out")(var_y))
return KerasModel(inputs,
outputs=outputs,
name="decoder_{}".format(self._side))
def decoder(self):
""" Decoder Network """
input_ = Input(shape=(4, 4, self.encoder_dim))
var_x = input_
var_x = UpscaleBlock(512)(var_x)
var_x = UpscaleBlock(256)(var_x)
var_x = UpscaleBlock(128)(var_x)
var_x = UpscaleBlock(64)(var_x)
var_x = Conv2DOutput(3, 5, name="face_out")(var_x)
outputs = [var_x]
if self.config.get("learn_mask", False):
var_y = input_
var_y = UpscaleBlock(512)(var_y)
var_y = UpscaleBlock(256)(var_y)
var_y = UpscaleBlock(128)(var_y)
var_y = UpscaleBlock(64)(var_y)
var_y = Conv2DOutput(1, 5, name="mask_out")(var_y)
outputs.append(var_y)
return KerasModel(input_, outputs=outputs, name="decoder")
def decoder(self, side):
""" DFL H128 Decoder """
input_ = Input(shape=(16, 16, self.encoder_dim))
var_x = input_
var_x = UpscaleBlock(self.encoder_dim, activation="leakyrelu")(var_x)
var_x = UpscaleBlock(self.encoder_dim // 2,
activation="leakyrelu")(var_x)
var_x = UpscaleBlock(self.encoder_dim // 4,
activation="leakyrelu")(var_x)
var_x = Conv2DOutput(3, 5, name=f"face_out_{side}")(var_x)
outputs = [var_x]
if self.config.get("learn_mask", False):
var_y = input_
var_y = UpscaleBlock(self.encoder_dim,
activation="leakyrelu")(var_y)
var_y = UpscaleBlock(self.encoder_dim // 2,
activation="leakyrelu")(var_y)
var_y = UpscaleBlock(self.encoder_dim // 4,
activation="leakyrelu")(var_y)
var_y = Conv2DOutput(1, 5, name=f"mask_out_{side}")(var_y)
outputs.append(var_y)
return KerasModel(input_, outputs=outputs, name=f"decoder_{side}")
def decoder_b(self):
""" DeLight Decoder B(new face) Network """
input_ = Input(shape=(4, 4, 1024))
dec_b_complexity = 512
mask_complexity = 128
var_xy = input_
var_xy = Upscale2xBlock(512,
scale_factor=self.upscale_ratio,
activation=None,
fast=False)(var_xy)
var_x = var_xy
var_x = LeakyReLU(alpha=0.2)(var_x)
var_x = ResidualBlock(512, use_bias=True)(var_x)
var_x = ResidualBlock(512, use_bias=False)(var_x)
var_x = ResidualBlock(512, use_bias=False)(var_x)
var_x = Upscale2xBlock(dec_b_complexity, activation=None,
fast=False)(var_x)
var_x = LeakyReLU(alpha=0.2)(var_x)
var_x = ResidualBlock(dec_b_complexity, use_bias=True)(var_x)
var_x = ResidualBlock(dec_b_complexity, use_bias=False)(var_x)
var_x = BatchNormalization()(var_x)
var_x = Upscale2xBlock(dec_b_complexity // 2,
activation=None,
fast=False)(var_x)
var_x = LeakyReLU(alpha=0.2)(var_x)
var_x = ResidualBlock(dec_b_complexity // 2, use_bias=True)(var_x)
var_x = Upscale2xBlock(dec_b_complexity // 4,
activation=None,
fast=False)(var_x)
var_x = LeakyReLU(alpha=0.2)(var_x)
var_x = ResidualBlock(dec_b_complexity // 4, use_bias=False)(var_x)
var_x = BatchNormalization()(var_x)
var_x = Upscale2xBlock(dec_b_complexity // 8,
activation="leakyrelu",
fast=False)(var_x)
var_x = Conv2DOutput(3, 5, name="face_out")(var_x)
outputs = [var_x]
if self.config.get("learn_mask", False):
var_y = var_xy # mask decoder
var_y = LeakyReLU(alpha=0.1)(var_y)
var_y = Upscale2xBlock(mask_complexity,
activation="leakyrelu",
fast=False)(var_y)
var_y = Upscale2xBlock(mask_complexity // 2,
activation="leakyrelu",
fast=False)(var_y)
var_y = Upscale2xBlock(mask_complexity // 4,
activation="leakyrelu",
fast=False)(var_y)
var_y = Upscale2xBlock(mask_complexity // 8,
activation="leakyrelu",
fast=False)(var_y)
var_y = Conv2DOutput(1, 5, name="mask_out")(var_y)
outputs.append(var_y)
return KerasModel([input_], outputs=outputs, name="decoder_b")