import copy import math import random from module.wavenet import SinusoidalPosEmb, WaveNet from transformer.embedding import SinePositionalEmbedding from transformer.transformer import LayerNorm, TransformerEncoder, TransformerEncoderLayer import numpy as np import torch from torch import nn from torch.nn import functional as F from module import commons from module import modules from module import attentions from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm from module.commons import init_weights, get_padding from module.quantize import VectorQuantize from text import symbols from torch.autograd.function import InplaceFunction class scalar_func9(InplaceFunction): @staticmethod def forward(ctx, input): ctx.input = input return torch.round(9*input)/9 @staticmethod def backward(ctx, grad_output): grad_input = grad_output.clone() return grad_input class TextEncoder(nn.Module): def __init__(self, out_channels, hidden_channels, filter_channels, n_heads, n_layers, kernel_size, p_dropout): super().__init__() self.out_channels = out_channels self.hidden_channels = hidden_channels self.filter_channels = filter_channels self.n_heads = n_heads self.n_layers = n_layers self.kernel_size = kernel_size self.p_dropout = p_dropout self.text_emb = nn.Embedding(len(symbols), 512) self.bert_proj = nn.Linear(1024, 512) norm_first = False self.position = SinePositionalEmbedding( 512, dropout=0.1, scale=False, alpha=True) self.encoder = TransformerEncoder( TransformerEncoderLayer( d_model=512, nhead=16, dim_feedforward=2048, dropout=0.1, batch_first=True, norm_first=False, ), num_layers=6, norm=LayerNorm(512) if norm_first else None, ) self.proj = nn.Conv1d(512, out_channels, 1) def forward_encoder(self, x, mask=None): if mask is not None: mask = ~mask.squeeze(1).bool() x = self.position(x) x, _ = self.encoder( (x, None), src_key_padding_mask=mask) return x def forward(self, x, x_lengths, bert): x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(-1)), 1).to(x.dtype) bert = self.bert_proj(bert.transpose(1, 2)) x = self.text_emb(x) + bert x = self.forward_encoder(x, x_mask) x = self.proj(x.transpose(1, 2)) * x_mask return x, x_mask class ResidualCouplingBlock(nn.Module): def __init__( self, channels, hidden_channels, kernel_size, dilation_rate, n_layers, n_flows=4, gin_channels=0, ): super(ResidualCouplingBlock, self).__init__() self.channels = channels self.hidden_channels = hidden_channels self.kernel_size = kernel_size self.dilation_rate = dilation_rate self.n_layers = n_layers self.n_flows = n_flows self.gin_channels = gin_channels self.flows = nn.ModuleList() for i in range(n_flows): self.flows.append( modules.ResidualCouplingLayer( channels, hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=gin_channels, mean_only=True, ) ) self.flows.append(modules.Flip()) def forward( self, x: torch.Tensor, x_mask: torch.Tensor, g=None, reverse: bool = False, ): if not reverse: for flow in self.flows: x, _ = flow(x, x_mask, g=g, reverse=reverse) else: for flow in self.flows[::-1]: x, _ = flow.forward(x, x_mask, g=g, reverse=reverse) return x def remove_weight_norm(self): for i in range(self.n_flows): self.flows[i * 2].remove_weight_norm() def __prepare_scriptable__(self): for i in range(self.n_flows): for hook in self.flows[i * 2]._forward_pre_hooks.values(): if ( hook.__module__ == "torch.nn.utils.weight_norm" and hook.__class__.__name__ == "WeightNorm" ): torch.nn.utils.remove_weight_norm(self.flows[i * 2]) return self class PosteriorEncoder(nn.Module): def __init__(self, in_channels, out_channels, hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=0): super().__init__() self.in_channels = in_channels self.out_channels = out_channels self.hidden_channels = hidden_channels self.kernel_size = kernel_size self.dilation_rate = dilation_rate self.n_layers = n_layers self.gin_channels = gin_channels self.pre = nn.Conv1d(in_channels, hidden_channels, 1) self.enc = modules.WN(hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=gin_channels) self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1) def forward(self, x, x_lengths, g=None): x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype) x = self.pre(x) * x_mask x = self.enc(x, x_mask, g=g) stats = self.proj(x) * x_mask m, logs = torch.split(stats, self.out_channels, dim=1) z = (m + torch.randn_like(m) * torch.exp(logs)) * x_mask return z, m, logs, x_mask class Generator(torch.nn.Module): def __init__(self, initial_channel, resblock, resblock_kernel_sizes, resblock_dilation_sizes, upsample_rates, upsample_initial_channel, upsample_kernel_sizes, gin_channels=0): super(Generator, self).__init__() self.num_kernels = len(resblock_kernel_sizes) self.num_upsamples = len(upsample_rates) self.conv_pre = Conv1d(initial_channel, upsample_initial_channel, 7, 1, padding=3) resblock = modules.ResBlock1 if resblock == '1' else modules.ResBlock2 self.ups = nn.ModuleList() for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)): self.ups.append(weight_norm( ConvTranspose1d(upsample_initial_channel // (2 ** i), upsample_initial_channel // (2 ** (i + 1)), k, u, padding=(k - u) // 2))) self.resblocks = nn.ModuleList() for i in range(len(self.ups)): ch = upsample_initial_channel // (2 ** (i + 1)) for j, (k, d) in enumerate(zip(resblock_kernel_sizes, resblock_dilation_sizes)): self.resblocks.append(resblock(ch, k, d)) self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False) self.ups.apply(init_weights) if gin_channels != 0: self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1) def forward(self, x, g=None): x = self.conv_pre(x) if g is not None: x = x + self.cond(g) for i in range(self.num_upsamples): x = F.leaky_relu(x, modules.LRELU_SLOPE) x = self.ups[i](x) xs = None for j in range(self.num_kernels): if xs is None: xs = self.resblocks[i * self.num_kernels + j](x) else: xs += self.resblocks[i * self.num_kernels + j](x) x = xs / self.num_kernels x = F.leaky_relu(x) x = self.conv_post(x) x = torch.tanh(x) return x def remove_weight_norm(self): print('Removing weight norm...') for l in self.ups: remove_weight_norm(l) for l in self.resblocks: l.remove_weight_norm() class DiscriminatorP(torch.nn.Module): def __init__(self, period, kernel_size=5, stride=3, use_spectral_norm=False): super(DiscriminatorP, self).__init__() self.period = period self.use_spectral_norm = use_spectral_norm norm_f = weight_norm if use_spectral_norm == False else spectral_norm self.convs = nn.ModuleList([ norm_f(Conv2d(1, 32, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))), norm_f(Conv2d(32, 128, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))), norm_f(Conv2d(128, 512, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))), norm_f(Conv2d(512, 1024, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))), norm_f(Conv2d(1024, 1024, (kernel_size, 1), 1, padding=(get_padding(kernel_size, 1), 0))), ]) self.conv_post = norm_f(Conv2d(1024, 1, (3, 1), 1, padding=(1, 0))) def forward(self, x): fmap = [] # 1d to 2d b, c, t = x.shape if t % self.period != 0: # pad first n_pad = self.period - (t % self.period) x = F.pad(x, (0, n_pad), "reflect") t = t + n_pad x = x.view(b, c, t // self.period, self.period) for l in self.convs: x = l(x) x = F.leaky_relu(x, modules.LRELU_SLOPE) fmap.append(x) x = self.conv_post(x) fmap.append(x) x = torch.flatten(x, 1, -1) return x, fmap class DiscriminatorS(torch.nn.Module): def __init__(self, use_spectral_norm=False): super(DiscriminatorS, self).__init__() norm_f = weight_norm if use_spectral_norm == False else spectral_norm self.convs = nn.ModuleList([ norm_f(Conv1d(1, 16, 15, 1, padding=7)), norm_f(Conv1d(16, 64, 41, 4, groups=4, padding=20)), norm_f(Conv1d(64, 256, 41, 4, groups=16, padding=20)), norm_f(Conv1d(256, 1024, 41, 4, groups=64, padding=20)), norm_f(Conv1d(1024, 1024, 41, 4, groups=256, padding=20)), norm_f(Conv1d(1024, 1024, 5, 1, padding=2)), ]) self.conv_post = norm_f(Conv1d(1024, 1, 3, 1, padding=1)) def forward(self, x): fmap = [] for l in self.convs: x = l(x) x = F.leaky_relu(x, modules.LRELU_SLOPE) fmap.append(x) x = self.conv_post(x) fmap.append(x) x = torch.flatten(x, 1, -1) return x, fmap class MultiPeriodDiscriminator(torch.nn.Module): def __init__(self, use_spectral_norm=False): super(MultiPeriodDiscriminator, self).__init__() periods = [2, 3, 5, 7, 11] discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)] discs = discs + [DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods] self.discriminators = nn.ModuleList(discs) def forward(self, y, y_hat): y_d_rs = [] y_d_gs = [] fmap_rs = [] fmap_gs = [] for i, d in enumerate(self.discriminators): y_d_r, fmap_r = d(y) y_d_g, fmap_g = d(y_hat) y_d_rs.append(y_d_r) y_d_gs.append(y_d_g) fmap_rs.append(fmap_r) fmap_gs.append(fmap_g) return y_d_rs, y_d_gs, fmap_rs, fmap_gs class ReferenceEncoder(nn.Module): ''' inputs --- [N, Ty/r, n_mels*r] mels outputs --- [N, ref_enc_gru_size] ''' def __init__(self, spec_channels, gin_channels=0): super().__init__() self.spec_channels = spec_channels ref_enc_filters = [32, 32, 64, 64, 128, 128] K = len(ref_enc_filters) filters = [1] + ref_enc_filters convs = [weight_norm(nn.Conv2d(in_channels=filters[i], out_channels=filters[i + 1], kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))) for i in range(K)] self.convs = nn.ModuleList(convs) # self.wns = nn.ModuleList([weight_norm(num_features=ref_enc_filters[i]) for i in range(K)]) out_channels = self.calculate_channels(spec_channels, 3, 2, 1, K) self.gru = nn.GRU(input_size=ref_enc_filters[-1] * out_channels, hidden_size=256 // 2, batch_first=True) self.proj = nn.Linear(128, gin_channels) def forward(self, inputs, mask=None): N = inputs.size(0) out = inputs.view(N, 1, -1, self.spec_channels) # [N, 1, Ty, n_freqs] for conv in self.convs: out = conv(out) # out = wn(out) out = F.relu(out) # [N, 128, Ty//2^K, n_mels//2^K] out = out.transpose(1, 2) # [N, Ty//2^K, 128, n_mels//2^K] T = out.size(1) N = out.size(0) out = out.contiguous().view(N, T, -1) # [N, Ty//2^K, 128*n_mels//2^K] self.gru.flatten_parameters() memory, out = self.gru(out) # out --- [1, N, 128] return self.proj(out.squeeze(0)).unsqueeze(-1) def calculate_channels(self, L, kernel_size, stride, pad, n_convs): for i in range(n_convs): L = (L - kernel_size + 2 * pad) // stride + 1 return L class FramePriorNet(nn.Module): def __init__(self, out_channels, hidden_channels, filter_channels, n_heads, n_layers, kernel_size, p_dropout): super().__init__() self.enc = attentions.Encoder( hidden_channels, filter_channels, n_heads, 6, kernel_size, p_dropout) self.out_proj = nn.Conv1d(hidden_channels, out_channels * 2, 1) self.out_channels = out_channels def forward(self, x, x_mask): x = self.enc(x, x_mask) stats = self.out_proj(x) * x_mask m, logs = torch.split(stats, self.out_channels, dim=1) return m, logs class ProsodyEncoder(nn.Module): def __init__(self, in_channels, hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels, vq_dim=16, ): super().__init__() self.in_proj = nn.Conv1d(in_channels, hidden_channels, 1) self.duration_emb = nn.Embedding(512, hidden_channels) self.enc = modules.WN(hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=gin_channels) # from dac self.duration_dec = modules.WN(hidden_channels, kernel_size, dilation_rate, 3, gin_channels=0) self.duration_proj = nn.Linear(hidden_channels, 512, False) self.vq_dim = vq_dim self.vq_down = nn.Conv1d(hidden_channels, self.vq_dim, 1) self.vq = scalar_func9() self.vq_up = nn.Conv1d(self.vq_dim, hidden_channels, 1) def encode_dur(self, dur): dur = dur.clamp(0, 511) dur_emb = self.duration_emb(dur) return dur_emb.transpose(1, 2), dur def calc_dur_loss(self, x, x_mask, dur): x = self.duration_dec(x, x_mask) logits = self.duration_proj(x.transpose(1, 2)) assert logits.shape[:2] == dur.shape[:2], (logits.shape, dur.shape) x_mask_bool = x_mask.squeeze(1).bool() dur = dur[x_mask_bool].view(-1) logits = logits[x_mask_bool].view(-1, 512) dur_loss = F.cross_entropy(logits, dur, reduction='mean') acc = (logits.argmax(-1) == dur).float().mean() * 100 pred_dur = logits.argmax(-1) return dur_loss, pred_dur def decode_dur(self, x, x_mask): x = self.duration_dec(x, x_mask) logits = self.duration_proj(x.transpose(1, 2)) logits = logits.view(-1, 512) pred_dur = logits.argmax(-1).reshape(-1, x.size(2)) return pred_dur def forward(self, y, x_mask, attn, dur, v_mask): y = self.in_proj(y) s = attn.sum(axis=2).unsqueeze(2) s[s == 0] = 1 attn_pool = attn / s x = torch.matmul(attn_pool.squeeze(1).transpose(1, 2), y.transpose(1, 2)).transpose(1, 2) x = x * v_mask.unsqueeze(1) g, dur = self.encode_dur(dur) x = self.enc(x, x_mask, g=g) x = self.vq_down(x) x = F.tanh(x) z = self.vq.apply(x) z_q = self.vq_up(z) quantize_loss = torch.tensor(0.) dur_loss, pred_dur = self.calc_dur_loss(z_q, x_mask, dur) return z_q, quantize_loss, z, dur_loss, pred_dur def decode(self, z_pred, x_mask): z = self.vq.apply(z_pred) z_q = self.vq_up(z) dur = self.decode_dur(z_q, x_mask) return z_q, dur class DiT(nn.Module): def __init__(self, io_channels, cond_channels): super().__init__() self.in_proj = nn.Linear(io_channels+cond_channels, 512) norm_first = False self.position = SinePositionalEmbedding( 512, dropout=0.1, scale=False, alpha=True) self.encoder = TransformerEncoder( TransformerEncoderLayer( d_model=512, nhead=16, dim_feedforward=2048, dropout=0.1, batch_first=True, norm_first=False, ), num_layers=6, norm=LayerNorm(512) if norm_first else None, ) self.proj = nn.Linear(512, io_channels) self.diffusion_embedding = SinusoidalPosEmb(512) def forward(self, x, t, cond): diffusion_step = self.diffusion_embedding(t).unsqueeze(1) x = torch.cat([x, cond], dim=1).transpose(1, 2) x = self.in_proj(x) x = torch.cat([diffusion_step, x], dim=1) x = self.position(x) x, _ = self.encoder( (x, None), src_key_padding_mask=None) x = x[:, 1:, :] x = self.proj(x).transpose(1, 2) return x from .edm import EDM2NetworkWrapper, edm_sampler class NARPredictor(nn.Module): def __init__(self, latent_dim=16, gin_channels=0): super().__init__() self.latent_dim = latent_dim self.bert_proj = nn.Linear(1024, 192) self.x_proj = nn.Linear(192, 192) self.g_emb = nn.Linear(256, 192) cond_channels = 192 net = DiT(latent_dim, cond_channels) self.edm_net = EDM2NetworkWrapper(net, use_fp16=False) def forward(self, x, x_mask, bert, spk_emb, diffusion_input): g = self.g_emb(spk_emb).unsqueeze(1) bert = self.bert_proj(bert.transpose(1, 2)) x = self.x_proj((x * x_mask).transpose(1, 2)) cond = (x + bert + g).transpose(1, 2) cfg_dropout_prob = 0.1 null_embed = torch.zeros_like(cond, device=cond.device) dropout_mask = torch.bernoulli(torch.full((cond.shape[0], 1, 1), cfg_dropout_prob, device=cond.device)).to(torch.bool) cond = torch.where(dropout_mask, null_embed, cond) P_std = 1.0 P_mean = -0.4 sigma_data = 0.4 rnd_normal = torch.randn([diffusion_input.shape[0], 1, 1], device=diffusion_input.device) sigma = (rnd_normal * P_std + P_mean).exp() weight = (sigma ** 2 + sigma_data ** 2) / (sigma * sigma_data) ** 2 noise = torch.randn_like(diffusion_input) * sigma denoised, logvar = self.edm_net(diffusion_input + noise, sigma, cond=cond, return_logvar=True) loss = (weight / logvar.exp()) * ((denoised - diffusion_input) ** 2) + logvar loss = loss.mean() return loss @torch.inference_mode() @torch.no_grad() def infer(self, x, x_mask, bert, spk_emb, step=32): g = self.g_emb(spk_emb).unsqueeze(1) bert = self.bert_proj(bert.transpose(1, 2)) x = self.x_proj((x * x_mask).transpose(1, 2)) cond = (x + bert + g).transpose(1, 2) noise = torch.randn([cond.shape[0], self.latent_dim, cond.shape[2]]).to(cond.device) fakes = edm_sampler(self.edm_net, noise, cond, num_steps=step, guidance=1.7) return fakes class SynthesizerTrn(nn.Module): """ Synthesizer for Training """ def __init__(self, spec_channels, segment_size, inter_channels, hidden_channels, filter_channels, n_heads, n_layers, kernel_size, p_dropout, resblock, resblock_kernel_sizes, resblock_dilation_sizes, upsample_rates, upsample_initial_channel, upsample_kernel_sizes, n_speakers=0, gin_channels=0, use_sdp=True, freeze_quantizer=False, **kwargs): super().__init__() self.spec_channels = spec_channels self.inter_channels = inter_channels self.hidden_channels = hidden_channels self.filter_channels = filter_channels self.n_heads = n_heads self.n_layers = n_layers self.kernel_size = kernel_size self.p_dropout = p_dropout self.resblock = resblock self.resblock_kernel_sizes = resblock_kernel_sizes self.resblock_dilation_sizes = resblock_dilation_sizes self.upsample_rates = upsample_rates self.upsample_initial_channel = upsample_initial_channel self.upsample_kernel_sizes = upsample_kernel_sizes self.segment_size = segment_size self.n_speakers = n_speakers gin_channels = hidden_channels self.gin_channels = gin_channels self.use_sdp = use_sdp self.enc_p = TextEncoder(inter_channels, hidden_channels, filter_channels, n_heads, n_layers, kernel_size, p_dropout) print('n_param of enc_p', sum(p.numel() for p in self.enc_p.parameters() if p.requires_grad) / 1e6, 'M') self.frame_prior_net = FramePriorNet(inter_channels, hidden_channels, filter_channels, n_heads, n_layers, kernel_size, p_dropout) self.dec = Generator(inter_channels, resblock, resblock_kernel_sizes, resblock_dilation_sizes, upsample_rates, upsample_initial_channel, upsample_kernel_sizes, gin_channels=gin_channels) self.enc_q = PosteriorEncoder(spec_channels, inter_channels, hidden_channels, 5, 1, 16, gin_channels=gin_channels) self.flow = ResidualCouplingBlock( inter_channels, hidden_channels, 5, 1, 3, gin_channels=gin_channels ) self.ref_enc = modules.MelStyleEncoder(spec_channels, style_vector_dim=gin_channels) # self.ref_enc_prosody = modules.MelStyleEncoder(768, style_vector_dim=gin_channels) # self.ref_enc = ReferenceEncoder(spec_channels, gin_channels) vq_dim = 16 self.prosody_encoder = ProsodyEncoder(768, hidden_channels, 5, 1, 6, gin_channels, vq_dim) self.prosody_predictor = NARPredictor(vq_dim, gin_channels=gin_channels) # if freeze_quantizer: # print('Freezing quantizer!!!') # print('Freezing quantizer!!!') # print('Freezing quantizer!!!') # print('Freezing quantizer!!!') # for param in self.prosody_encoder.parameters(): # param.requires_grad = False def forward(self, x, x_lengths, y, y_lengths, ssl, duration, bert, spk_emb,prosody_predict_only=False): y_mask = torch.unsqueeze(commons.sequence_mask(y_lengths, y.size(-1)), 1).to(y.dtype) g = self.ref_enc(y * y_mask, y_mask) x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(-1)), 1).to(y.dtype) attn_mask = torch.unsqueeze(x_mask, 2) * torch.unsqueeze(y_mask, -1) attn = commons.generate_path(duration.unsqueeze(1), attn_mask) v_mask = (x > 0).float() z_q, quantize_loss, indices, dur_loss, pred_dur = self.prosody_encoder(ssl, x_mask, attn, duration, v_mask) x, x_mask = self.enc_p(x, x_lengths, bert) prosody_predict_loss = self.prosody_predictor(x, x_mask, bert, spk_emb, indices) return prosody_predict_loss, z_q def reconstruct(self, x, x_lengths, y, y_lengths, ssl, duration, bert, spk_emb, noise_scale=.4): y_mask = torch.unsqueeze(commons.sequence_mask(y_lengths, y.size(-1)), 1).to(y.dtype) g = self.ref_enc(y * y_mask, y_mask) x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(-1)), 1).to(y.dtype) # attn_mask = torch.unsqueeze(x_mask, 2) * torch.unsqueeze(y_mask, -1) # attn = commons.generate_path(duration.unsqueeze(1), attn_mask) # v_mask = (x > 0).float() # _, _, pred_prosody_codes, _, _ = self.prosody_encoder(ssl, x_mask, attn, duration,v_mask) x, x_mask = self.enc_p(x, x_lengths, bert) pred_prosody_codes = self.prosody_predictor.infer(x, x_mask, bert, spk_emb) z_q, duration = self.prosody_encoder.decode(pred_prosody_codes, x_mask) total_duration = torch.sum(duration, dim=1) y_lengths = total_duration.long() y_mask = torch.unsqueeze(commons.sequence_mask(y_lengths, y_lengths.max()), 1).float() attn_mask = torch.unsqueeze(x_mask, 2) * torch.unsqueeze(y_mask, -1) attn = commons.generate_path(duration.unsqueeze(1), attn_mask) x = x + z_q frame_x = torch.matmul(attn.squeeze(1), x.transpose(1, 2)).transpose(1, 2) m_p, logs_p = self.frame_prior_net(frame_x, y_mask) z_p = m_p + torch.randn_like(m_p) * torch.exp(logs_p) * noise_scale z = self.flow(z_p, y_mask, g=g, reverse=True) o = self.dec((z * y_mask), g=g) return o, attn, y_mask, (z, z_p, m_p, logs_p) def infer(self, x, x_lengths, ref, bert, spk_emb, noise_scale=.4): g = self.ref_enc(ref) x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(-1)), 1).to(bert.dtype) x, x_mask = self.enc_p(x, x_lengths, bert) pred_prosody_codes = self.prosody_predictor.infer(x, x_mask, bert, spk_emb) z_q, duration = self.prosody_encoder.decode(pred_prosody_codes, x_mask) total_duration = torch.sum(duration, dim=1) y_lengths = total_duration.long() y_mask = torch.unsqueeze(commons.sequence_mask(y_lengths, y_lengths.max()), 1).float() attn_mask = torch.unsqueeze(x_mask, 2) * torch.unsqueeze(y_mask, -1) attn = commons.generate_path(duration.unsqueeze(1), attn_mask) x = x + z_q frame_x = torch.matmul(attn.squeeze(1), x.transpose(1, 2)).transpose(1, 2) m_p, logs_p = self.frame_prior_net(frame_x, y_mask) z_p = m_p + torch.randn_like(m_p) * torch.exp(logs_p) * noise_scale z = self.flow(z_p, y_mask, g=g, reverse=True) o = self.dec((z * y_mask), g=g) return o