File size: 2,682 Bytes
7375975 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 |
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 # [B,C,T]
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
|