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": # root scheduler val_to_mask = 1 - (r ** .5) elif mode == "linear": # linear scheduler val_to_mask = 1 - r elif mode == "square": # square scheduler val_to_mask = 1 - (r ** 2) elif mode == "cosine": # cosine scheduler val_to_mask = torch.cos(r * math.pi * 0.5) elif mode == "arccos": # arc cosine scheduler val_to_mask = torch.arccos(r) / (math.pi * 0.5) else: return # fill the scheduler by the ratio of tokens to predict at each step sche = (val_to_mask / val_to_mask.sum()) * tgt_length sche = sche.round() sche[sche == 0] = 1 # add 1 to predict a least 1 token / step sche[-1] += tgt_length - sche.sum() # need to sum up nb of code 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) # 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_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)