import torch import torch.nn as nn import torch.optim as optim import pytorch_lightning.core.module as pl import matplotlib.pyplot as plt from module import commons from transformer.embedding import SinePositionalEmbedding from transformer.transformer import LayerNorm, TransformerEncoder, TransformerEncoderLayer plt.switch_backend('agg') import random import math import torch.nn.functional as F from tqdm import tqdm class SinusoidalPosEmb(nn.Module): def __init__(self, dim): super().__init__() self.dim = dim def forward(self, x): device = x.device half_dim = self.dim // 2 emb = math.log(10000) / (half_dim - 1) emb = torch.exp(torch.arange(half_dim, device=device) * -emb) emb = x[:, None] * emb[None, :] emb = torch.cat((emb.sin(), emb.cos()), dim=-1) return emb class DiT(nn.Module): def __init__(self, io_channels, concat_cond_channels, prepend_cond_channels): super().__init__() self.in_proj = nn.Linear(io_channels+concat_cond_channels, 512) self.prepend_proj = nn.Linear(prepend_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=12, 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, concat_cond, prepend_cond, mask=None): if mask is None: mask = torch.ones(x.shape[0], x.shape[-1], device=x.device).long() mask_bool = ~mask.bool() prepend_cond = self.prepend_proj(prepend_cond.transpose(1, 2)) prepend_cond_len = prepend_cond.shape[1] diffusion_step = self.diffusion_embedding(t).unsqueeze(1) x = torch.cat([x, concat_cond], dim=1).transpose(1, 2) x = self.in_proj(x) x = torch.cat([diffusion_step, prepend_cond, x], dim=1) mask_bool = torch.cat([torch.zeros([mask_bool.shape[0], prepend_cond_len+1], device=mask_bool.device).bool(), mask_bool], dim=1) x = self.position(x) x, _ = self.encoder( (x, None), src_key_padding_mask=mask_bool) x = x[:, prepend_cond_len+1:, :] x = self.proj(x).transpose(1, 2) return x class ReFlow(nn.Module): def __init__(self, io_channels, cond_channels, ): super().__init__() self.model = DiT(io_channels, cond_channels, io_channels) self.io_channels = io_channels self.rng = torch.quasirandom.SobolEngine(1, scramble=True) def forward(self, reals, cond, prompt,mask): # reals : [B, 128, T] # cond : [B, 192, T] # mask : [B, 1, T] t = self.rng.draw(reals.shape[0])[:, 0].to(reals.device) alphas, sigmas = 1 - t, t alphas = alphas[:, None, None] sigmas = sigmas[:, None, None] noise = torch.randn_like(reals) noised_inputs = reals * alphas + noise * sigmas targets = noise - reals output = self.model(noised_inputs, t, cond,prompt, mask) # mse loss with mask loss = F.mse_loss(output, targets, reduction='none') loss = loss * mask.unsqueeze(1) return loss.mean() def sample(self, cond,prompt, steps, sigma_max=1): x = torch.randn(cond.shape[0], self.io_channels, cond.shape[2]).to(cond.device) t = torch.linspace(sigma_max, 0, steps + 1) for t_curr, t_prev in tqdm(zip(t[:-1], t[1:])): t_curr_tensor = t_curr * torch.ones( (x.shape[0],), dtype=x.dtype, device=x.device ) dt = t_prev - t_curr x = x + dt * self.model(x, t_curr_tensor, cond,prompt) return x class NARPredictor(nn.Module): def __init__(self, latent_dim=16): super().__init__() self.latent_dim = latent_dim self.bert_proj = nn.Linear(1024, 192) self.x_emb = nn.Embedding(1024, 192) self.reflow = ReFlow(latent_dim, 192) def forward(self, x, bert, prompt, diffusion_input, mask): bert = self.bert_proj(bert.transpose(1, 2)) x = self.x_emb(x) cond = (x + bert).transpose(1, 2) loss = self.reflow(diffusion_input, cond,prompt,mask) return loss @torch.inference_mode() @torch.no_grad() def infer(self, x, bert, prompt, step, guidance): bert = self.bert_proj(bert.transpose(1, 2)) x = self.x_emb(x) cond = (x + bert).transpose(1, 2) fakes = self.reflow.sample(cond,prompt, step) return fakes class Wav2TTS(pl.LightningModule): def __init__(self, hp): super().__init__() self.model = NARPredictor(latent_dim=8) self.lr = hp.lr def configure_optimizers(self): print('train with lr ', self.lr) optimizer = optim.AdamW([*self.parameters()], lr=self.lr, betas=(0.9, 0.95), weight_decay=0.1) return optimizer def training_step(self, batch, batch_idx): loss = self.step(batch) self.log("train/loss", loss, on_step=True, prog_bar=True) # self.log("train/quantize_loss", quantize_loss, on_step=True, prog_bar=True) return loss def validation_step(self, batch, batch_idx): loss = self.step(batch) self.log("val/loss", loss, on_step=True, prog_bar=True) def step(self, batch): phone_features = batch['phone'] lengths = batch['length'] bert_feature = batch['bert_feature'] latent = batch['latent'] mask = commons.sequence_mask(lengths, latent.size(-1)).long() # [1,1,1,1,0...] prompt_len = random.randint(1, lengths.min()-1) # print('prompt len:', prompt_len, 'latent len:', latent.size(-1), 'min len:', lengths.min()) prompt = latent[:, :, :prompt_len] latent = latent[:, :, prompt_len:] phone_features = phone_features[:, prompt_len:] bert_feature = bert_feature[:,:, prompt_len:] mask = mask[:, prompt_len:] loss = self.model(phone_features, bert_feature, prompt, latent, mask) return loss @torch.inference_mode() @torch.no_grad() def inference(self, phonemes, bert_feature,prompt, n_steps=32, guidance=4): # speaker_embedding = self.spk_proj(spk_emb) # speaker_embedding, commitment_loss, codebook_loss, indices, z_e = self.spk_vq(speaker_embedding.unsqueeze(-1)) # speaker_embedding = speaker_embedding.squeeze(-1) # print('quantized spk code:', indices) output = self.model.infer(phonemes, bert_feature, prompt, n_steps, guidance) return output