| 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): |
| |
| |
| |
| 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) |
| |
| 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) |
| |
| 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() |
|
|
| prompt_len = random.randint(1, lengths.min()-1) |
| |
| 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): |
| |
| |
| |
| |
|
|
| output = self.model.infer(phonemes, bert_feature, prompt, n_steps, guidance) |
| return output |
