|
|
import torch |
|
|
from torch import nn |
|
|
|
|
|
|
|
|
class LayerNorm(torch.nn.LayerNorm): |
|
|
"""Layer normalization module. |
|
|
:param int nout: output dim size |
|
|
:param int dim: dimension to be normalized |
|
|
""" |
|
|
|
|
|
def __init__(self, nout, dim=-1, eps=1e-5): |
|
|
"""Construct an LayerNorm object.""" |
|
|
super(LayerNorm, self).__init__(nout, eps=eps) |
|
|
self.dim = dim |
|
|
|
|
|
def forward(self, x): |
|
|
"""Apply layer normalization. |
|
|
:param torch.Tensor x: input tensor |
|
|
:return: layer normalized tensor |
|
|
:rtype torch.Tensor |
|
|
""" |
|
|
if self.dim == -1: |
|
|
return super(LayerNorm, self).forward(x) |
|
|
return super(LayerNorm, self).forward(x.transpose(1, -1)).transpose(1, -1) |
|
|
|
|
|
class Conditional_LayerNorm(nn.Module): |
|
|
def __init__(self, |
|
|
normal_shape, |
|
|
epsilon=1e-5 |
|
|
): |
|
|
super(Conditional_LayerNorm, self).__init__() |
|
|
if isinstance(normal_shape, int): |
|
|
self.normal_shape = normal_shape |
|
|
self.speaker_embedding_dim = normal_shape |
|
|
self.epsilon = epsilon |
|
|
self.W_scale = nn.Linear(self.speaker_embedding_dim, self.normal_shape) |
|
|
self.W_bias = nn.Linear(self.speaker_embedding_dim, self.normal_shape) |
|
|
self.reset_parameters() |
|
|
|
|
|
def reset_parameters(self): |
|
|
torch.nn.init.constant_(self.W_scale.weight, 0.0) |
|
|
torch.nn.init.constant_(self.W_scale.bias, 1.0) |
|
|
torch.nn.init.constant_(self.W_bias.weight, 0.0) |
|
|
torch.nn.init.constant_(self.W_bias.bias, 0.0) |
|
|
|
|
|
def forward(self, x, speaker_embedding): |
|
|
''' |
|
|
x shape: [T, B, C] |
|
|
''' |
|
|
mean = x.mean(dim=-1, keepdim=True) |
|
|
var = ((x - mean) ** 2).mean(dim=-1, keepdim=True) |
|
|
std = (var + self.epsilon).sqrt() |
|
|
y = (x - mean) / std |
|
|
scale = self.W_scale(speaker_embedding).transpose(0,1) |
|
|
bias = self.W_bias(speaker_embedding).transpose(0,1) |
|
|
y *= scale |
|
|
y += bias |
|
|
return y |
|
|
|
|
|
|
|
|
class Reshape(nn.Module): |
|
|
def __init__(self, *args): |
|
|
super(Reshape, self).__init__() |
|
|
self.shape = args |
|
|
|
|
|
def forward(self, x): |
|
|
return x.view(self.shape) |
|
|
|
|
|
|
|
|
class Permute(nn.Module): |
|
|
def __init__(self, *args): |
|
|
super(Permute, self).__init__() |
|
|
self.args = args |
|
|
|
|
|
def forward(self, x): |
|
|
return x.permute(self.args) |
|
|
|
|
|
|
|
|
def Embedding(num_embeddings, embedding_dim, padding_idx=None): |
|
|
m = nn.Embedding(num_embeddings, embedding_dim, padding_idx=padding_idx) |
|
|
nn.init.normal_(m.weight, mean=0, std=embedding_dim ** -0.5) |
|
|
if padding_idx is not None: |
|
|
nn.init.constant_(m.weight[padding_idx], 0) |
|
|
return m |
|
|
|
