| from module.wavenet import SinusoidalPosEmb, WaveNet |
| from text import symbols |
| 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.models import TextEncoder, PosteriorEncoder, FramePriorNet, Generator, ProsodyEncoder, ResidualCouplingBlock |
| from module import commons |
| from module import modules |
| from omegaconf import OmegaConf |
| from module.maskgit import MaskGIT |
|
|
| 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.g_emb = nn.Linear(256, 192) |
|
|
| self.text_emb = nn.Embedding(len(symbols), 192) |
|
|
|
|
| cond_channels = 192 |
| args_dict = { |
| "sched_mode": "arccos", |
| "mask_value": 512, |
| "codebook_size": 512, |
| "drop_label": 0.1, |
| "debug": False, |
| "iter": 0, |
| "global_epoch": 0, |
| "is_multi_gpus": False, |
| "is_master": True |
| } |
| args = OmegaConf.create(args_dict) |
| self.maskgit = MaskGIT(args) |
| self.args = args |
|
|
| def forward(self, x, x_mask, bert, spk_emb, code): |
| g = self.g_emb(spk_emb).unsqueeze(1) |
| bert = self.bert_proj(bert.transpose(1, 2)) |
| x = self.text_emb(x) |
|
|
|
|
|
|
| cond = (x + bert + g) |
|
|
| padding_mask = ~x_mask.squeeze(1).bool() |
|
|
|
|
| drop_label = torch.empty(cond.size()).uniform_(0, 1) < self.args.drop_label |
| masked_code, mask = self.maskgit.get_mask_code(code, value=self.args.mask_value, codebook_size=self.maskgit.codebook_size) |
| pred = self.maskgit.vit(masked_code, cond, drop_label=drop_label) |
| |
| code_label = code.clone() |
| code_label[padding_mask] = self.maskgit.codebook_size |
| loss = self.maskgit.criterion(pred.reshape(-1, self.maskgit.codebook_size + 1), code_label.view(-1)) |
| 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.text_emb(x) |
| cond = (x + bert + g) |
|
|
| y_pred = self.maskgit.sample(None, cond=cond,w=1.5) |
|
|
| return y_pred |
|
|
|
|
| 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) |
| vq_dim = 512 |
| self.prosody_encoder = ProsodyEncoder(768, hidden_channels, 5, 1, 6, gin_channels, vq_dim) |
|
|
| self.prosody_predictor = NARPredictor(vq_dim, gin_channels=gin_channels) |
|
|
| 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) |
| text_long = x.clone() |
| 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) |
|
|
| prosody_predict_loss = self.prosody_predictor(x, x_mask, bert, spk_emb, indices) |
| return prosody_predict_loss, indices |
|
|
| 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) |
|
|
| |
| |
| |
| |
|
|
| pred_prosody_codes = self.prosody_predictor.infer(x, x_mask, bert, spk_emb) |
|
|
| x = self.enc_p(x, x_mask, bert) |
|
|
| 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) |
|
|
