| from omegaconf import OmegaConf |
| from module.aligner import AlignmentEncoder |
| from module.maskgit import ImageBert, MLMLoss |
| 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, mono_align_and_get_loss |
| from module import commons |
| from module import modules |
| import math |
|
|
|
|
| import random |
| from tqdm import tqdm |
|
|
|
|
| class NARPredictor(nn.Module): |
| def __init__(self, codebook_size=128, gin_channels=0): |
| super().__init__() |
| conf = { |
| "model": { |
| "vq_model": { |
| "codebook_size": codebook_size, |
| "token_size": 12, |
| "use_l2_norm": True, |
| "commitment_cost": 0.25, |
| "vit_enc_model_size": "base", |
| "vit_dec_model_size": "base", |
| "vit_enc_patch_size": 16, |
| "vit_dec_patch_size": 16, |
| "num_latent_tokens": 64, |
| "finetune_decoder": True |
| }, |
| "generator": { |
| "model_type": "ViT", |
| "hidden_size": 512, |
| "num_hidden_layers": 12, |
| "num_attention_heads": 16, |
| "intermediate_size": 2048, |
| "dropout": 0.1, |
| "attn_drop": 0.1, |
| "num_steps": 8, |
| "class_label_dropout": 0.1, |
| "image_seq_len": 2048, |
| "condition_dim": 192, |
| "randomize_temperature": 1.0, |
| "guidance_scale": 4.5, |
| "guidance_decay": "constant" |
| } |
|
|
| }, |
| "losses": { |
| "label_smoothing": 0.1, |
| "loss_weight_unmasked_token": 0.1 |
| } |
|
|
| } |
| config = OmegaConf.create(conf) |
|
|
| self.bert_proj = nn.Linear(1024, 192) |
| self.ph_emb = nn.Embedding(1024, 192) |
| self.g_emb = nn.Linear(256, 192) |
| self.loss_module = MLMLoss(config) |
| self.model = ImageBert(config) |
|
|
|
|
| def forward(self, x, x_mask, bert, spk_emb, tgt_code): |
| g = self.g_emb(spk_emb).unsqueeze(1) |
| bert = self.bert_proj(bert.transpose(1, 2)) |
| ph = self.ph_emb(x) |
|
|
| conditions = ph + bert + g |
| input_tokens = tgt_code |
|
|
| masked_tokens, masks = self.model.masking_input_tokens( |
| input_tokens) |
| logits = self.model(masked_tokens, conditions, |
| cond_drop_prob=0.1) |
|
|
| masks = masks & (x_mask.squeeze(1).bool()) |
| loss, loss_dict = self.loss_module(logits, input_tokens, weights=masks) |
| print('acc:', loss_dict['correct_tokens']) |
| return loss |
|
|
| @torch.inference_mode() |
| @torch.no_grad() |
| def infer(self, x, x_mask, bert, spk_emb, step=5, sched_mode="square", temp=30, randomize="None", r_temp=30, cfg_scale=1.5): |
|
|
| g = self.g_emb(spk_emb).unsqueeze(1) |
| bert = self.bert_proj(bert.transpose(1, 2)) |
| ph = self.ph_emb(x) |
|
|
| conditions = ph + bert + g |
| code = self.model.generate( |
| conditions, |
| guidance_scale=0.5, |
| ) |
| return code |
|
|
| def adap_sche(self, step, mode="arccos", leave=False, tgt_length=None): |
| """ Create a sampling scheduler |
| :param |
| step -> int: number of prediction during inference |
| mode -> str: the rate of value to unmask |
| leave -> bool: tqdm arg on either to keep the bar or not |
| :return |
| scheduler -> torch.LongTensor(): the list of token to predict at each step |
| """ |
| r = torch.linspace(1, 0, step) |
| if mode == "root": |
| val_to_mask = 1 - (r ** .5) |
| elif mode == "linear": |
| val_to_mask = 1 - r |
| elif mode == "square": |
| val_to_mask = 1 - (r ** 2) |
| elif mode == "cosine": |
| val_to_mask = torch.cos(r * math.pi * 0.5) |
| elif mode == "arccos": |
| val_to_mask = torch.arccos(r) / (math.pi * 0.5) |
| else: |
| return |
|
|
| |
| sche = (val_to_mask / val_to_mask.sum()) * tgt_length |
| sche = sche.round() |
| sche[sche == 0] = 1 |
| sche[-1] += tgt_length - sche.sum() |
| return tqdm(sche.int(), leave=leave) |
|
|
|
|
| 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.aligner = AlignmentEncoder( |
| n_mel_channels=hidden_channels, |
| n_att_channels=256, |
| n_text_channels=128, |
| temperature=0.0005, |
| multi_speaker=True, |
| spk_channel=gin_channels |
| ) |
|
|
| self.prosody_predictor = NARPredictor(vq_dim, gin_channels=gin_channels) |
|
|
| def forward(self, x, x_lengths, y, y_lengths, ssl, attn_priors, bert, spk_emb, ): |
| x_long = x.clone() |
| 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) |
| v_mask = (x > 0).float() |
|
|
| x, x_align = self.enc_p(x, x_mask, bert, g) |
| z, m_q, logs_q, y_mask = self.enc_q(y, y_lengths, g=g) |
|
|
| attn_out, attn, duration = mono_align_and_get_loss(self.aligner, x_align, z.detach(), x_mask, y_mask, attn_priors, x_lengths, y_lengths, g) |
|
|
| 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_long, x_mask, bert, spk_emb, indices) |
| return prosody_predict_loss, indices |
|
|
| def reconstruct(self, x, x_lengths, y, y_lengths, ssl, bert, spk_emb, noise_scale=.4): |
| x_long = x.clone() |
|
|
| 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) |
|
|
| |
| |
| |
| |
| x, x_align = self.enc_p(x, x_mask, bert, g) |
|
|
| pred_prosody_codes = self.prosody_predictor.infer(x_long, 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) |
|
|
