wehub-resource-sync
130 lines
4.3 KiB
Python
130 lines
4.3 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
"""Residual block module in WaveNet.
|
|
|
|
This code is modified from https://github.com/r9y9/wavenet_vocoder.
|
|
|
|
"""
|
|
|
|
import math
|
|
|
|
import torch
|
|
import torch.nn.functional as F
|
|
|
|
|
|
class Conv1d(torch.nn.Conv1d):
|
|
"""Conv1d module with customized initialization."""
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
"""Initialize Conv1d module."""
|
|
super(Conv1d, self).__init__(*args, **kwargs)
|
|
|
|
def reset_parameters(self):
|
|
"""Reset parameters."""
|
|
torch.nn.init.kaiming_normal_(self.weight, nonlinearity="relu")
|
|
if self.bias is not None:
|
|
torch.nn.init.constant_(self.bias, 0.0)
|
|
|
|
|
|
class Conv1d1x1(Conv1d):
|
|
"""1x1 Conv1d with customized initialization."""
|
|
|
|
def __init__(self, in_channels, out_channels, bias):
|
|
"""Initialize 1x1 Conv1d module."""
|
|
super(Conv1d1x1, self).__init__(in_channels, out_channels,
|
|
kernel_size=1, padding=0,
|
|
dilation=1, bias=bias)
|
|
|
|
|
|
class ResidualBlock(torch.nn.Module):
|
|
"""Residual block module in WaveNet."""
|
|
|
|
def __init__(self,
|
|
kernel_size=3,
|
|
residual_channels=64,
|
|
gate_channels=128,
|
|
skip_channels=64,
|
|
aux_channels=80,
|
|
dropout=0.0,
|
|
dilation=1,
|
|
bias=True,
|
|
use_causal_conv=False
|
|
):
|
|
"""Initialize ResidualBlock module.
|
|
|
|
Args:
|
|
kernel_size (int): Kernel size of dilation convolution layer.
|
|
residual_channels (int): Number of channels for residual connection.
|
|
skip_channels (int): Number of channels for skip connection.
|
|
aux_channels (int): Local conditioning channels i.e. auxiliary input dimension.
|
|
dropout (float): Dropout probability.
|
|
dilation (int): Dilation factor.
|
|
bias (bool): Whether to add bias parameter in convolution layers.
|
|
use_causal_conv (bool): Whether to use use_causal_conv or non-use_causal_conv convolution.
|
|
|
|
"""
|
|
super(ResidualBlock, self).__init__()
|
|
self.dropout = dropout
|
|
# no future time stamps available
|
|
if use_causal_conv:
|
|
padding = (kernel_size - 1) * dilation
|
|
else:
|
|
assert (kernel_size - 1) % 2 == 0, "Not support even number kernel size."
|
|
padding = (kernel_size - 1) // 2 * dilation
|
|
self.use_causal_conv = use_causal_conv
|
|
|
|
# dilation conv
|
|
self.conv = Conv1d(residual_channels, gate_channels, kernel_size,
|
|
padding=padding, dilation=dilation, bias=bias)
|
|
|
|
# local conditioning
|
|
if aux_channels > 0:
|
|
self.conv1x1_aux = Conv1d1x1(aux_channels, gate_channels, bias=False)
|
|
else:
|
|
self.conv1x1_aux = None
|
|
|
|
# conv output is split into two groups
|
|
gate_out_channels = gate_channels // 2
|
|
self.conv1x1_out = Conv1d1x1(gate_out_channels, residual_channels, bias=bias)
|
|
self.conv1x1_skip = Conv1d1x1(gate_out_channels, skip_channels, bias=bias)
|
|
|
|
def forward(self, x, c):
|
|
"""Calculate forward propagation.
|
|
|
|
Args:
|
|
x (Tensor): Input tensor (B, residual_channels, T).
|
|
c (Tensor): Local conditioning auxiliary tensor (B, aux_channels, T).
|
|
|
|
Returns:
|
|
Tensor: Output tensor for residual connection (B, residual_channels, T).
|
|
Tensor: Output tensor for skip connection (B, skip_channels, T).
|
|
|
|
"""
|
|
residual = x
|
|
x = F.dropout(x, p=self.dropout, training=self.training)
|
|
x = self.conv(x)
|
|
|
|
# remove future time steps if use_causal_conv conv
|
|
x = x[:, :, :residual.size(-1)] if self.use_causal_conv else x
|
|
|
|
# split into two part for gated activation
|
|
splitdim = 1
|
|
xa, xb = x.split(x.size(splitdim) // 2, dim=splitdim)
|
|
|
|
# local conditioning
|
|
if c is not None:
|
|
assert self.conv1x1_aux is not None
|
|
c = self.conv1x1_aux(c)
|
|
ca, cb = c.split(c.size(splitdim) // 2, dim=splitdim)
|
|
xa, xb = xa + ca, xb + cb
|
|
|
|
x = torch.tanh(xa) * torch.sigmoid(xb)
|
|
|
|
# for skip connection
|
|
s = self.conv1x1_skip(x)
|
|
|
|
# for residual connection
|
|
x = (self.conv1x1_out(x) + residual) * math.sqrt(0.5)
|
|
|
|
return x, s
|