magvits_data / code /module /models_s1_adp.py

arcadiaaaaa

Add files using upload-large-folder tool

138fdcc verified over 1 year ago

11 kB

from omegaconf import OmegaConf
from module.aligner import AlignmentEncoder
from module.maskgit import 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
from einops import rearrange


import random
from tqdm import tqdm

from .edm import EDM2NetworkWrapper, edm_sampler

class DiT(nn.Module):
    def __init__(self, io_channels, cond_channels):
        super().__init__()
        self.in_proj = nn.Linear(io_channels+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=6,
            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, cond):
        diffusion_step = self.diffusion_embedding(t).unsqueeze(1)
        x = torch.cat([x, cond], dim=1).transpose(1, 2)
        x = self.in_proj(x)
        x = torch.cat([diffusion_step, x], dim=1)
        x = self.position(x)
        x, _ = self.encoder(
            (x, None), src_key_padding_mask=None)
        x = x[:, 1:, :]
        x = self.proj(x).transpose(1, 2)
        return x

from audio_diffusion_pytorch import DiffusionModel, UNetV0, VDiffusion, VSampler

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)



        cond_channels = 192
        net = DiT(latent_dim, cond_channels)
        self.model = DiffusionModel(
            net=net, # The model type used for diffusion (U-Net V0 in this case)
            in_channels=2, # U-Net: number of input/output (audio) channels
            channels=[8, 32], # U-Net: channels at each layer
            factors=[1, 4,], # U-Net: downsampling and upsampling factors at each layer
            items=[1, 2], # U-Net: number of repeating items at each layer
            attentions=[0, 0, ], # U-Net: attention enabled/disabled at each layer
            attention_heads=8, # U-Net: number of attention heads per attention item
            attention_features=64, # U-Net: number of attention features per attention item
            diffusion_t=VDiffusion, # The diffusion method used
            sampler_t=VSampler, # The diffusion sampler used
        )


    def forward(self, x, x_mask, bert, spk_emb, diffusion_input):
        g = self.g_emb(spk_emb).unsqueeze(1)
        bert = self.bert_proj(bert.transpose(1, 2))
        x = self.x_proj((x * x_mask).transpose(1, 2))

        cond = (x + bert + g).transpose(1, 2)


        # cfg_dropout_prob = 0.1
        # null_embed = torch.zeros_like(cond, device=cond.device)
        # dropout_mask = torch.bernoulli(torch.full((cond.shape[0], 1, 1), cfg_dropout_prob, device=cond.device)).to(torch.bool)
        # cond = torch.where(dropout_mask, null_embed, cond)



        # P_std = 1.0
        # P_mean = -0.4
        # sigma_data = 0.4


        # rnd_normal = torch.randn([diffusion_input.shape[0], 1, 1], device=diffusion_input.device)
        # sigma = (rnd_normal * P_std + P_mean).exp()
        # weight = (sigma ** 2 + sigma_data ** 2) / (sigma * sigma_data) ** 2
        # noise = torch.randn_like(diffusion_input) * sigma
        # denoised, logvar = self.edm_net(diffusion_input + noise, sigma, cond=cond, return_logvar=True)
        # loss = (weight / logvar.exp()) * ((denoised - diffusion_input) ** 2) + logvar
        # loss = loss.mean()
        loss = self.model(diffusion_input, cond=cond)
        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.x_proj((x * x_mask).transpose(1, 2))
        cond = (x + bert + g).transpose(1, 2)


        noise = torch.randn([cond.shape[0], self.latent_dim, cond.shape[2]]).to(cond.device)

        fakes = self.model.sample(noise, num_steps=step,cond=cond, show_progress=True)


        return fakes


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 = 4
        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)
        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, 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)

        pred_prosody_codes = self.prosody_predictor.infer(x, 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)

	from omegaconf import OmegaConf
	from module.aligner import AlignmentEncoder
	from module.maskgit import 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
	from einops import rearrange


	import random
	from tqdm import tqdm

	from .edm import EDM2NetworkWrapper, edm_sampler

	class DiT(nn.Module):
	def __init__(self, io_channels, cond_channels):
	super().__init__()
	self.in_proj = nn.Linear(io_channels+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=6,
	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, cond):
	diffusion_step = self.diffusion_embedding(t).unsqueeze(1)
	x = torch.cat([x, cond], dim=1).transpose(1, 2)
	x = self.in_proj(x)
	x = torch.cat([diffusion_step, x], dim=1)
	x = self.position(x)
	x, _ = self.encoder(
	(x, None), src_key_padding_mask=None)
	x = x[:, 1:, :]
	x = self.proj(x).transpose(1, 2)
	return x

	from audio_diffusion_pytorch import DiffusionModel, UNetV0, VDiffusion, VSampler

	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)



	cond_channels = 192
	net = DiT(latent_dim, cond_channels)
	self.model = DiffusionModel(
	net=net, # The model type used for diffusion (U-Net V0 in this case)
	in_channels=2, # U-Net: number of input/output (audio) channels
	channels=[8, 32], # U-Net: channels at each layer
	factors=[1, 4,], # U-Net: downsampling and upsampling factors at each layer
	items=[1, 2], # U-Net: number of repeating items at each layer
	attentions=[0, 0, ], # U-Net: attention enabled/disabled at each layer
	attention_heads=8, # U-Net: number of attention heads per attention item
	attention_features=64, # U-Net: number of attention features per attention item
	diffusion_t=VDiffusion, # The diffusion method used
	sampler_t=VSampler, # The diffusion sampler used
	)


	def forward(self, x, x_mask, bert, spk_emb, diffusion_input):
	g = self.g_emb(spk_emb).unsqueeze(1)
	bert = self.bert_proj(bert.transpose(1, 2))
	x = self.x_proj((x * x_mask).transpose(1, 2))

	cond = (x + bert + g).transpose(1, 2)


	# cfg_dropout_prob = 0.1
	# null_embed = torch.zeros_like(cond, device=cond.device)
	# dropout_mask = torch.bernoulli(torch.full((cond.shape[0], 1, 1), cfg_dropout_prob, device=cond.device)).to(torch.bool)
	# cond = torch.where(dropout_mask, null_embed, cond)



	# P_std = 1.0
	# P_mean = -0.4
	# sigma_data = 0.4


	# rnd_normal = torch.randn([diffusion_input.shape[0], 1, 1], device=diffusion_input.device)
	# sigma = (rnd_normal * P_std + P_mean).exp()
	# weight = (sigma 2 + sigma_data 2) / (sigma * sigma_data) ** 2
	# noise = torch.randn_like(diffusion_input) * sigma
	# denoised, logvar = self.edm_net(diffusion_input + noise, sigma, cond=cond, return_logvar=True)
	# loss = (weight / logvar.exp()) * ((denoised - diffusion_input) ** 2) + logvar
	# loss = loss.mean()
	loss = self.model(diffusion_input, cond=cond)
	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.x_proj((x * x_mask).transpose(1, 2))
	cond = (x + bert + g).transpose(1, 2)


	noise = torch.randn([cond.shape[0], self.latent_dim, cond.shape[2]]).to(cond.device)

	fakes = self.model.sample(noise, num_steps=step,cond=cond, show_progress=True)


	return fakes


	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 = 4
	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)
	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, 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)

	pred_prosody_codes = self.prosody_predictor.infer(x, 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)