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.x_proj = nn.Linear(192, 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) # The unmasked tokens prediction # Cross-entropy loss 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) # 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) 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)