| 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 |
|
|
