fish_speech/models/flow_dit/modules/mrte.py

import torch
import torch.nn as nn
import torch.nn.functional as F

from einops import rearrange

from typing import List
import sys
sys.path.append('')

from fish_speech.models.flow_dit.modules.embedding import TokenEmbedding, SinePositionalEmbedding
from fish_speech.models.flow_dit.modules.convnet import ConvNetDouble, ConvNet
from fish_speech.models.flow_dit.modules.transformer import (TransformerEncoder,
                                 TransformerEncoderLayer,
                                 MultiHeadAttention)
from fish_speech.models.flow_dit.modules.utils import make_attn_mask


class MRTE(nn.Module):
    def __init__(
            self,
            mel_bins: int = 100,
            mel_activation: str = 'ReLU',
            mel_kernel_size: int = 3,
            mel_stride: int = 16,
            mel_n_layer: int = 5,
            mel_n_stack: int = 5,
            mel_n_block: int = 2,
            content_ff_dim: int = 1024,
            content_n_heads: int = 2,
            content_n_layers: int = 8,
            hidden_size: int = 512,
            token_vocab_size: int = 320,
            dropout: float = 0.1
    ):
        super(MRTE, self).__init__()

        self.n_heads = content_n_heads
        self.mel_bins = mel_bins
        self.hidden_size = hidden_size

        self.token_embedding = TokenEmbedding(
            dim_model=hidden_size,
            vocab_size=token_vocab_size+1,
            dropout=dropout,
            padding_idx=token_vocab_size,
        )

        self.token_pos_embedding = SinePositionalEmbedding(
            dim_model=hidden_size,
            dropout=dropout,
        )

        self.mel_encoder_middle_layer = nn.Conv1d(
            in_channels=hidden_size,
            out_channels=hidden_size,
            kernel_size=mel_stride + 1,
            stride=mel_stride,
            padding=(mel_stride) // 2,
        )
        self.mel_encoder = ConvNetDouble(
            in_channels=mel_bins,
            out_channels=hidden_size,
            hidden_size=hidden_size,
            n_layers=mel_n_layer,
            n_stacks=mel_n_stack,
            n_blocks=mel_n_block,
            middle_layer=self.mel_encoder_middle_layer,
            kernel_size=mel_kernel_size,
            activation=mel_activation,
        )

        self.token_encoder = TransformerEncoder(
            TransformerEncoderLayer(
                dim=hidden_size,
                ff_dim=content_ff_dim,
                conv_ff=True,
                n_heads=content_n_heads,
                dropout=dropout,
            ),
            num_layers=content_n_layers,
        )

        self.mha = MultiHeadAttention(
            qkv_dim=hidden_size,
            n_heads=1,
            dropout=dropout,
        )
        self.norm = nn.LayerNorm(hidden_size)
        self.activation = nn.ReLU()      

    def tc_latent(
            self,
            token: torch.Tensor,  # (B, T)
            token_lens: torch.Tensor,  # (B,)
            mel: torch.Tensor,  # (B, T, mel_bins)
    ):
        token_emb = self.token_embedding(token)
        token_pos = self.token_pos_embedding(token_emb)

        mel = rearrange(mel, 'B T D -> B D T')
        mel_context = self.mel_encoder(mel)
        mel_context = rearrange(mel_context, 'B D T -> B T D')
        token_x = self.token_encoder(token_pos)

        tc_latent = self.mha(token_x, kv=mel_context)
        tc_latent = self.norm(tc_latent)
        tc_latent = self.activation(tc_latent)

        return tc_latent

    def forward(
            self,
            token: torch.Tensor,  # (B, T)
            token_lens: torch.Tensor,  # (B,)
            mel: torch.Tensor,  # (B, T, mel_bins)
    ):
        tc_latent = self.tc_latent(token, token_lens, mel) # (B,T,C)
        return tc_latent


class MRTE_Text(nn.Module):
    def __init__(
            self,
            mel_activation: str = 'ReLU',
            mel_kernel_size: int = 3,
            mel_stride: int = 16,
            mel_n_layer: int = 5,
            mel_n_stack: int = 5,
            mel_n_block: int = 2,
            content_ff_dim: int = 1024,
            content_n_heads: int = 2,
            content_n_layers: int = 8,
            hidden_size: int = 512,
            dropout: float = 0.1,
            text_encoder: torch.nn.Module = None
    ):
        super(MRTE_Text, self).__init__()

        self.n_heads = content_n_heads
        self.hidden_size = hidden_size
        self.text_encoder = text_encoder

        self.token_pos_embedding = SinePositionalEmbedding(
            dim_model=hidden_size,
            dropout=dropout,
        )

        self.token_encoder = TransformerEncoder(
            TransformerEncoderLayer(
                dim=hidden_size,
                ff_dim=content_ff_dim,
                conv_ff=True,
                n_heads=content_n_heads,
                dropout=dropout,
            ),
            num_layers=content_n_layers,
        )

        self.mha = MultiHeadAttention(
            qkv_dim=hidden_size,
            n_heads=1,
            dropout=dropout,
        )
        self.norm = nn.LayerNorm(hidden_size)
        self.activation = nn.ReLU()      

    def tc_latent(
            self,
            token_emb: torch.Tensor,  # (B, T, C)
            token_mask: torch.Tensor,  # (B,T)
            text_embed: torch.Tensor,  # (B, T, C)
            text_mask: torch.Tensor,  # (B,T)
            text_lengths: torch.Tensor,  # (B,)
    ):
        token_pos = self.token_pos_embedding(token_emb)

        text_context,_ = self.text_encoder(text_embed,text_lengths)
        token_x = self.token_encoder(token_pos) * token_mask

        tc_latent = self.mha(token_x*token_mask, kv=text_context*text_mask)+token_x
        tc_latent = self.norm(tc_latent)
        tc_latent = self.activation(tc_latent)

        return tc_latent

    def forward(
            self,
            token_emb: torch.Tensor,  # (B, T, C)
            token_mask: torch.Tensor,  # (B,T)
            text_embed: torch.Tensor,  # (B, T, C)
            text_mask: torch.Tensor,  # (B,T)
            text_lengths: torch.Tensor,  # (B,)
    ):
        tc_latent = self.tc_latent(token_emb, token_mask, text_embed, text_mask, text_lengths) # (B,T,C)
        return tc_latent


class MRTE_Mel(nn.Module):
    def __init__(
            self,
            mel_bins: int = 100,
            mel_activation: str = 'ReLU',
            mel_kernel_size: int = 3,
            mel_stride: int = 16,
            mel_n_layer: int = 5,
            mel_n_stack: int = 5,
            mel_n_block: int = 2,
            content_ff_dim: int = 1024,
            content_n_heads: int = 2,
            content_n_layers: int = 8,
            hidden_size: int = 512,
            token_vocab_size: int = 320,
            dropout: float = 0.1
    ):
        super(MRTE_Mel, self).__init__()

        self.n_heads = content_n_heads
        self.mel_bins = mel_bins
        self.hidden_size = hidden_size

        self.token_pos_embedding = SinePositionalEmbedding(
            dim_model=hidden_size,
            dropout=dropout,
        )

        self.mel_encoder_middle_layer = nn.Conv1d(
            in_channels=hidden_size,
            out_channels=hidden_size,
            kernel_size=mel_stride + 1,
            stride=mel_stride,
            padding=(mel_stride) // 2,
        )
        self.mel_encoder = ConvNetDouble(
            in_channels=mel_bins,
            out_channels=hidden_size,
            hidden_size=hidden_size,
            n_layers=mel_n_layer,
            n_stacks=mel_n_stack,
            n_blocks=mel_n_block,
            middle_layer=self.mel_encoder_middle_layer,
            kernel_size=mel_kernel_size,
            activation=mel_activation,
        )

        self.token_encoder = TransformerEncoder(
            TransformerEncoderLayer(
                dim=hidden_size,
                ff_dim=content_ff_dim,
                conv_ff=True,
                n_heads=content_n_heads,
                dropout=dropout,
            ),
            num_layers=content_n_layers,
        )

        self.mha = MultiHeadAttention(
            qkv_dim=hidden_size,
            n_heads=1,
            dropout=dropout,
        )
        self.norm = nn.LayerNorm(hidden_size)
        self.activation = nn.ReLU()      

    def tc_latent(
            self,
            token_embed: torch.Tensor,  # (B, T, C)
            token_lens: torch.Tensor,  # (B,)
            mel: torch.Tensor,  # (B, T, mel_bins)
    ):
        token_pos = self.token_pos_embedding(token_embed)

        mel = rearrange(mel, 'B T D -> B D T')
        mel_context = self.mel_encoder(mel)
        mel_context = rearrange(mel_context, 'B D T -> B T D')
        token_x = self.token_encoder(token_pos)

        tc_latent = self.mha(token_x, kv=mel_context) + token_x
        tc_latent = self.norm(tc_latent)
        tc_latent = self.activation(tc_latent)

        return tc_latent

    def forward(
            self,
            token_embed: torch.Tensor,  # (B, T, C)
            token_lens: torch.Tensor,  # (B,)
            mel: torch.Tensor,  # (B, T, mel_bins)
    ):
        tc_latent = self.tc_latent(token_embed, token_lens, mel) # (B,T,C)
        return tc_latent



def test():
    mrte = MRTE(
        mel_bins=100,
        mel_activation='ReLU',
        mel_kernel_size= 3,
        mel_stride=16,
        mel_n_layer=5,
        mel_n_stack= 5,
        mel_n_block= 2,
        content_ff_dim=1024,
        content_n_heads=2,
        content_n_layers=8,
        hidden_size=512,
        token_vocab_size=500,
        dropout=0.1
    )
    device = "cuda:0"
    mrte = mrte.to(device)


    t = torch.randint(0, 500, (2, 10)).to(dtype=torch.int64).to(device)
    tl = torch.tensor([6, 10]).to(dtype=torch.int64).to(device)
    m = torch.randn(2, 347, 100).to(device)

    out = mrte(t, tl, m)
    print(out.shape)