magvits_data / code /module /models prepend.py
arcadiaaaaa
Add files using upload-large-folder tool
11b4f27 verified over 1 year ago
31.2 kB
import copy
import math
import random

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 import commons
from module import modules
from module import attentions

from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm

from module.commons import init_weights, get_padding
from module.quantize import VectorQuantize
from text import symbols


class TextEncoder(nn.Module):
    def __init__(self,
                 out_channels,
                 hidden_channels,
                 filter_channels,
                 n_heads,
                 n_layers,
                 kernel_size,
                 p_dropout):
        super().__init__()
        self.out_channels = out_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.text_emb = nn.Embedding(len(symbols), 512)
        self.bert_proj = nn.Linear(1024, 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.Conv1d(512, out_channels, 1)

    def forward_encoder(self, x, mask=None):
        if mask is not None:
            mask = ~mask.squeeze(1).bool()
        x = self.position(x)
        x, _ = self.encoder(
            (x, None), src_key_padding_mask=mask)
        return x

    def forward(self, x, x_lengths, bert):
        x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(-1)), 1).to(x.dtype)
        bert = self.bert_proj(bert.transpose(1, 2))
        x = self.text_emb(x) + bert
        x = self.forward_encoder(x, x_mask)
        x = self.proj(x.transpose(1, 2)) * x_mask
        return x, x_mask

class ResidualCouplingBlock(nn.Module):
    def __init__(
        self,
        channels,
        hidden_channels,
        kernel_size,
        dilation_rate,
        n_layers,
        n_flows=4,
        gin_channels=0,
    ):
        super(ResidualCouplingBlock, self).__init__()
        self.channels = channels
        self.hidden_channels = hidden_channels
        self.kernel_size = kernel_size
        self.dilation_rate = dilation_rate
        self.n_layers = n_layers
        self.n_flows = n_flows
        self.gin_channels = gin_channels

        self.flows = nn.ModuleList()
        for i in range(n_flows):
            self.flows.append(
                modules.ResidualCouplingLayer(
                    channels,
                    hidden_channels,
                    kernel_size,
                    dilation_rate,
                    n_layers,
                    gin_channels=gin_channels,
                    mean_only=True,
                )
            )
            self.flows.append(modules.Flip())

    def forward(
        self,
        x: torch.Tensor,
        x_mask: torch.Tensor,
        g=None,
        reverse: bool = False,
    ):
        if not reverse:
            for flow in self.flows:
                x, _ = flow(x, x_mask, g=g, reverse=reverse)
        else:
            for flow in self.flows[::-1]:
                x, _ = flow.forward(x, x_mask, g=g, reverse=reverse)
        return x

    def remove_weight_norm(self):
        for i in range(self.n_flows):
            self.flows[i * 2].remove_weight_norm()

    def __prepare_scriptable__(self):
        for i in range(self.n_flows):
            for hook in self.flows[i * 2]._forward_pre_hooks.values():
                if (
                    hook.__module__ == "torch.nn.utils.weight_norm"
                    and hook.__class__.__name__ == "WeightNorm"
                ):
                    torch.nn.utils.remove_weight_norm(self.flows[i * 2])

        return self



class PosteriorEncoder(nn.Module):
    def __init__(self,
                 in_channels,
                 out_channels,
                 hidden_channels,
                 kernel_size,
                 dilation_rate,
                 n_layers,
                 gin_channels=0):
        super().__init__()
        self.in_channels = in_channels
        self.out_channels = out_channels
        self.hidden_channels = hidden_channels
        self.kernel_size = kernel_size
        self.dilation_rate = dilation_rate
        self.n_layers = n_layers
        self.gin_channels = gin_channels

        self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
        self.enc = modules.WN(hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=gin_channels)
        self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)

    def forward(self, x, x_lengths, g=None):
        x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
        x = self.pre(x) * x_mask
        x = self.enc(x, x_mask, g=g)
        stats = self.proj(x) * x_mask
        m, logs = torch.split(stats, self.out_channels, dim=1)
        z = (m + torch.randn_like(m) * torch.exp(logs)) * x_mask
        return z, m, logs, x_mask


class Generator(torch.nn.Module):
    def __init__(self, initial_channel, resblock, resblock_kernel_sizes, resblock_dilation_sizes, upsample_rates,
                 upsample_initial_channel, upsample_kernel_sizes, gin_channels=0):
        super(Generator, self).__init__()
        self.num_kernels = len(resblock_kernel_sizes)
        self.num_upsamples = len(upsample_rates)
        self.conv_pre = Conv1d(initial_channel, upsample_initial_channel, 7, 1, padding=3)
        resblock = modules.ResBlock1 if resblock == '1' else modules.ResBlock2

        self.ups = nn.ModuleList()
        for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
            self.ups.append(weight_norm(
                ConvTranspose1d(upsample_initial_channel // (2 ** i), upsample_initial_channel // (2 ** (i + 1)),
                                k, u, padding=(k - u) // 2)))

        self.resblocks = nn.ModuleList()
        for i in range(len(self.ups)):
            ch = upsample_initial_channel // (2 ** (i + 1))
            for j, (k, d) in enumerate(zip(resblock_kernel_sizes, resblock_dilation_sizes)):
                self.resblocks.append(resblock(ch, k, d))

        self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False)
        self.ups.apply(init_weights)

        if gin_channels != 0:
            self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)

    def forward(self, x, g=None):
        x = self.conv_pre(x)
        if g is not None:
            x = x + self.cond(g)

        for i in range(self.num_upsamples):
            x = F.leaky_relu(x, modules.LRELU_SLOPE)
            x = self.ups[i](x)
            xs = None
            for j in range(self.num_kernels):
                if xs is None:
                    xs = self.resblocks[i * self.num_kernels + j](x)
                else:
                    xs += self.resblocks[i * self.num_kernels + j](x)
            x = xs / self.num_kernels
        x = F.leaky_relu(x)
        x = self.conv_post(x)
        x = torch.tanh(x)

        return x

    def remove_weight_norm(self):
        print('Removing weight norm...')
        for l in self.ups:
            remove_weight_norm(l)
        for l in self.resblocks:
            l.remove_weight_norm()


class DiscriminatorP(torch.nn.Module):
    def __init__(self, period, kernel_size=5, stride=3, use_spectral_norm=False):
        super(DiscriminatorP, self).__init__()
        self.period = period
        self.use_spectral_norm = use_spectral_norm
        norm_f = weight_norm if use_spectral_norm == False else spectral_norm
        self.convs = nn.ModuleList([
            norm_f(Conv2d(1, 32, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
            norm_f(Conv2d(32, 128, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
            norm_f(Conv2d(128, 512, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
            norm_f(Conv2d(512, 1024, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
            norm_f(Conv2d(1024, 1024, (kernel_size, 1), 1, padding=(get_padding(kernel_size, 1), 0))),
        ])
        self.conv_post = norm_f(Conv2d(1024, 1, (3, 1), 1, padding=(1, 0)))

    def forward(self, x):
        fmap = []

        # 1d to 2d
        b, c, t = x.shape
        if t % self.period != 0:  # pad first
            n_pad = self.period - (t % self.period)
            x = F.pad(x, (0, n_pad), "reflect")
            t = t + n_pad
        x = x.view(b, c, t // self.period, self.period)

        for l in self.convs:
            x = l(x)
            x = F.leaky_relu(x, modules.LRELU_SLOPE)
            fmap.append(x)
        x = self.conv_post(x)
        fmap.append(x)
        x = torch.flatten(x, 1, -1)

        return x, fmap


class DiscriminatorS(torch.nn.Module):
    def __init__(self, use_spectral_norm=False):
        super(DiscriminatorS, self).__init__()
        norm_f = weight_norm if use_spectral_norm == False else spectral_norm
        self.convs = nn.ModuleList([
            norm_f(Conv1d(1, 16, 15, 1, padding=7)),
            norm_f(Conv1d(16, 64, 41, 4, groups=4, padding=20)),
            norm_f(Conv1d(64, 256, 41, 4, groups=16, padding=20)),
            norm_f(Conv1d(256, 1024, 41, 4, groups=64, padding=20)),
            norm_f(Conv1d(1024, 1024, 41, 4, groups=256, padding=20)),
            norm_f(Conv1d(1024, 1024, 5, 1, padding=2)),
        ])
        self.conv_post = norm_f(Conv1d(1024, 1, 3, 1, padding=1))

    def forward(self, x):
        fmap = []

        for l in self.convs:
            x = l(x)
            x = F.leaky_relu(x, modules.LRELU_SLOPE)
            fmap.append(x)
        x = self.conv_post(x)
        fmap.append(x)
        x = torch.flatten(x, 1, -1)

        return x, fmap


class MultiPeriodDiscriminator(torch.nn.Module):
    def __init__(self, use_spectral_norm=False):
        super(MultiPeriodDiscriminator, self).__init__()
        periods = [2, 3, 5, 7, 11]

        discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
        discs = discs + [DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods]
        self.discriminators = nn.ModuleList(discs)

    def forward(self, y, y_hat):
        y_d_rs = []
        y_d_gs = []
        fmap_rs = []
        fmap_gs = []
        for i, d in enumerate(self.discriminators):
            y_d_r, fmap_r = d(y)
            y_d_g, fmap_g = d(y_hat)
            y_d_rs.append(y_d_r)
            y_d_gs.append(y_d_g)
            fmap_rs.append(fmap_r)
            fmap_gs.append(fmap_g)

        return y_d_rs, y_d_gs, fmap_rs, fmap_gs


class ReferenceEncoder(nn.Module):
    '''
    inputs --- [N, Ty/r, n_mels*r]  mels
    outputs --- [N, ref_enc_gru_size]
    '''

    def __init__(self, spec_channels, gin_channels=0):

        super().__init__()
        self.spec_channels = spec_channels
        ref_enc_filters = [32, 32, 64, 64, 128, 128]
        K = len(ref_enc_filters)
        filters = [1] + ref_enc_filters
        convs = [weight_norm(nn.Conv2d(in_channels=filters[i],
                                       out_channels=filters[i + 1],
                                       kernel_size=(3, 3),
                                       stride=(2, 2),
                                       padding=(1, 1))) for i in range(K)]
        self.convs = nn.ModuleList(convs)
        # self.wns = nn.ModuleList([weight_norm(num_features=ref_enc_filters[i]) for i in range(K)])

        out_channels = self.calculate_channels(spec_channels, 3, 2, 1, K)
        self.gru = nn.GRU(input_size=ref_enc_filters[-1] * out_channels,
                          hidden_size=256 // 2,
                          batch_first=True)
        self.proj = nn.Linear(128, gin_channels)

    def forward(self, inputs, mask=None):
        N = inputs.size(0)
        out = inputs.view(N, 1, -1, self.spec_channels)  # [N, 1, Ty, n_freqs]
        for conv in self.convs:
            out = conv(out)
            # out = wn(out)
            out = F.relu(out)  # [N, 128, Ty//2^K, n_mels//2^K]

        out = out.transpose(1, 2)  # [N, Ty//2^K, 128, n_mels//2^K]
        T = out.size(1)
        N = out.size(0)
        out = out.contiguous().view(N, T, -1)  # [N, Ty//2^K, 128*n_mels//2^K]

        self.gru.flatten_parameters()
        memory, out = self.gru(out)  # out --- [1, N, 128]

        return self.proj(out.squeeze(0)).unsqueeze(-1)

    def calculate_channels(self, L, kernel_size, stride, pad, n_convs):
        for i in range(n_convs):
            L = (L - kernel_size + 2 * pad) // stride + 1
        return L


class FramePriorNet(nn.Module):
    def __init__(self,
                 out_channels,
                 hidden_channels,
                 filter_channels,
                 n_heads,
                 n_layers,
                 kernel_size,
                 p_dropout):
        super().__init__()

        self.enc = attentions.Encoder(
            hidden_channels,
            filter_channels,
            n_heads,
            6,
            kernel_size,
            p_dropout)
        self.out_proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
        self.out_channels = out_channels

    def forward(self, x, x_mask):
        x = self.enc(x, x_mask)
        stats = self.out_proj(x) * x_mask
        m, logs = torch.split(stats, self.out_channels, dim=1)
        return m, logs


class ProsodyEncoder(nn.Module):
    def __init__(self,
                 in_channels,
                 hidden_channels,
                 kernel_size,
                 dilation_rate,
                 n_layers,
                 gin_channels,
                 codebook_size=128,
                 ):
        super().__init__()

        self.in_proj = nn.Conv1d(in_channels, hidden_channels, 1)
        self.duration_emb = nn.Embedding(512, hidden_channels)
        self.enc = modules.WN(hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=gin_channels)
        # from dac
        print(codebook_size)
        print(codebook_size)
        print(codebook_size)
        print(codebook_size)
        self.prosody_quantizer = VectorQuantize(
            input_dim=hidden_channels,
            codebook_size=codebook_size,
            codebook_dim=8
        )
        self.duration_dec = modules.WN(hidden_channels, kernel_size, dilation_rate, 3, gin_channels=0)
        self.duration_proj = nn.Linear(hidden_channels, 512, False)

    def encode_dur(self, dur):
        dur = dur.clamp(0, 511)

        dur_emb = self.duration_emb(dur)
        return dur_emb.transpose(1, 2), dur

    def calc_dur_loss(self, x, x_mask, dur):
        x = self.duration_dec(x, x_mask)
        logits = self.duration_proj(x.transpose(1, 2))
        assert logits.shape[:2] == dur.shape[:2], (logits.shape, dur.shape)
        x_mask_bool = x_mask.squeeze(1).bool()
        dur = dur[x_mask_bool].view(-1)
        logits = logits[x_mask_bool].view(-1, 512)
        dur_loss = F.cross_entropy(logits, dur, reduction='mean')
        acc = (logits.argmax(-1) == dur).float().mean() * 100
        print('dur acc', acc.item())
        pred_dur = logits.argmax(-1)

        return dur_loss, pred_dur

    def decode_dur(self, x, x_mask):
        x = self.duration_dec(x, x_mask)
        logits = self.duration_proj(x.transpose(1, 2))
        logits = logits.view(-1, 512)
        pred_dur = logits.argmax(-1).reshape(-1, x.size(2))
        return pred_dur

    def forward(self, y, x_mask, attn, dur, v_mask):
        y = self.in_proj(y)
        s = attn.sum(axis=2).unsqueeze(2)
        s[s == 0] = 1
        attn_pool = attn / s
        x = torch.matmul(attn_pool.squeeze(1).transpose(1, 2), y.transpose(1, 2)).transpose(1, 2)
        x = x * v_mask.unsqueeze(1)

        g, dur = self.encode_dur(dur)
        x = self.enc(x, x_mask, g=g)
        z_q, commitment_loss, codebook_loss, indices, z_e = self.prosody_quantizer(x)
        quantize_loss = codebook_loss + 0.25 * commitment_loss
        dur_loss, pred_dur = self.calc_dur_loss(z_q, x_mask, dur)
        return z_q, quantize_loss, indices, dur_loss, pred_dur

    def decode(self, indices, x_mask):
        z_q = self.prosody_quantizer.decode(indices)
        dur = self.decode_dur(z_q, x_mask)
        return z_q, dur


import random
from tqdm import tqdm


class NARPredictor(nn.Module):
    def __init__(self, codebook_size=128, gin_channels=0):
        super().__init__()

        norm_first = False
        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.num_head = 16
        self.cond_position = SinePositionalEmbedding(
            512, dropout=0.1, scale=False, alpha=True)
        self.q_position = SinePositionalEmbedding(
            512, dropout=0.1, scale=False, alpha=True)
        self.bert_proj = nn.Linear(1024, 512)
        self.x_proj = nn.Linear(192, 512)
        self.g_emb = nn.Linear(256, 512)

        self.proj = nn.Linear(512, codebook_size, bias=False)

        self.quantize_embedding = nn.Embedding(codebook_size + 1, 512)
        self.n_codes = codebook_size

    def forward_encoder(self, cond,q, mask=None):
        l = cond.shape[1]
        cond = self.cond_position(cond)
        q = self.q_position(q)
        x = torch.cat([cond, q], dim=1)
        
        x, _ = self.encoder(
            (x, None))
        x = x[:, l:]
        audio_output = self.proj(x)
        return audio_output

    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))
        x = self.x_proj((x * x_mask).transpose(1, 2))

        x = x + bert + g

        # make mask
        quantization = tgt_code.clone()

        mask_ratio = random.uniform(0, 1)
        mask = torch.bernoulli(mask_ratio * torch.ones_like(quantization)).bool()
        quantization[mask] = self.n_codes
        quantization_emb = self.quantize_embedding(quantization)

        audio_output = self.forward_encoder(x, quantization_emb, mask=x_mask)

        x_mask_bool = x_mask.squeeze(1).bool()
        tgt_mask = x_mask_bool & mask

        audio_output = audio_output[tgt_mask]
        tgt_code = tgt_code[tgt_mask].view(-1)
        predict_loss = F.cross_entropy(audio_output, tgt_code, reduction='mean')
        acc = (audio_output.argmax(-1) == tgt_code).float().mean() * 100
        print('prosody acc', acc.item())
        return predict_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):

        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))
        x = x + bert + g

        nb_sample = x.size(0)
        tgt_length = x.size(1)

        code = torch.full((nb_sample, tgt_length), self.n_codes).long().to(x.device)

        mask = torch.ones((nb_sample, tgt_length)).to(x.device)

        scheduler = self.adap_sche(step, mode=sched_mode, tgt_length=tgt_length)
        for indice, t in enumerate(scheduler):
            # print('step:', indice, '\nmask:', mask, '\nt:', t, '\ncode', code, '\n\n')
            if mask.sum() < t:  # Cannot predict more token than 16*16 or 32*32
                t = int(mask.sum().item())
                print(f"Warning: cannot predict {t} tokens, only {mask.sum().item()} tokens left")
            if mask.sum() == 0:  # Break if code is fully predicted
                break

            quantization_emb = self.quantize_embedding(code.clone())
            logit = self.forward_encoder(x, quantization_emb)

            prob = torch.softmax(logit * temp, -1)
            distri = torch.distributions.Categorical(probs=prob)
            pred_code = distri.sample()

            conf = torch.gather(prob, 2, pred_code.view(nb_sample, tgt_length, 1))

            if randomize == "linear":  # add gumbel noise decreasing over the sampling process
                ratio = (indice / (len(scheduler) - 1))
                rand = r_temp * np.random.gumbel(size=(nb_sample, tgt_length)) * (1 - ratio)
                conf = torch.log(conf.squeeze()) + torch.from_numpy(rand).to(x.device)
            elif randomize == "warm_up":  # chose random sample for the 2 first steps
                conf = torch.rand_like(conf) if indice < 2 else conf
            elif randomize == "random":  # chose random prediction at each step
                conf = torch.rand_like(conf)

            # do not predict on already predicted tokens
            conf[~mask.bool()] = -math.inf

            # chose the predicted token with the highest confidence
            tresh_conf, indice_mask = torch.topk(conf.view(nb_sample, -1), k=t, dim=-1)
            tresh_conf = tresh_conf[:, -1]

            # replace the chosen tokens
            conf = (conf >= tresh_conf.unsqueeze(-1)).view(nb_sample, tgt_length)
            f_mask = (mask.float() * conf.float()).bool()
            code[f_mask] = pred_code[f_mask]

            # update the mask
            for i_mask, ind_mask in enumerate(indice_mask):
                mask[i_mask, ind_mask] = 0
        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)
        # self.ref_enc_prosody = modules.MelStyleEncoder(768, style_vector_dim=gin_channels)
        # self.ref_enc = ReferenceEncoder(spec_channels, gin_channels)
        codebook_size = 1024
        self.prosody_encoder = ProsodyEncoder(768, hidden_channels, 5, 1, 6, gin_channels, codebook_size)
        self.prosody_predictor = NARPredictor(codebook_size, gin_channels=gin_channels)

        # if freeze_quantizer:
        #     print('Freezing quantizer!!!')
        #     print('Freezing quantizer!!!')
        #     print('Freezing quantizer!!!')
        #     print('Freezing quantizer!!!')

        # for param in self.prosody_encoder.parameters():
        #     param.requires_grad = False

    def forward(self, x, x_lengths, y, y_lengths, ssl, duration, bert, spk_emb):
        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()

        z_q, quantize_loss, indices, dur_loss, pred_dur = self.prosody_encoder(ssl, x_mask, attn, duration, v_mask)

        x, x_mask = self.enc_p(x, x_lengths, bert)
        prosody_predict_loss = self.prosody_predictor(x, x_mask, bert, spk_emb, indices)
        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, m_q, logs_q, y_mask = self.enc_q(y, y_lengths, g=g)
        z_p = self.flow(z, y_mask, g=g)

        z_slice, ids_slice = commons.rand_slice_segments(z, y_lengths, self.segment_size)
        o = self.dec(z_slice, g=g)
        return o, attn, ids_slice, x_mask, y_mask, (
        z, z_p, m_p, logs_p, m_q, logs_q), z_q, quantize_loss.mean(), dur_loss, pred_dur, prosody_predict_loss

    def reconstruct(self, x, x_lengths, y, y_lengths, ssl, duration, bert, spk_emb, noise_scale=.4):
        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_mask = self.enc_p(x, x_lengths, bert)

        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)

    def infer(self, x, x_lengths, ref, bert, spk_emb, noise_scale=.4):
        g = self.ref_enc(ref)

        x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(-1)), 1).to(bert.dtype)

        x, x_mask = self.enc_p(x, x_lengths, bert)
        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