Upload 11 files

.gitattributes

@@ -57,3 +57,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+transformer_transducer_epoch_1 filter=lfs diff=lfs merge=lfs -text
+transformer_transducer_epoch_2 filter=lfs diff=lfs merge=lfs -text
+transformer_transducer_epoch_3 filter=lfs diff=lfs merge=lfs -text
+transformer_transducer_epoch_4 filter=lfs diff=lfs merge=lfs -text
+transformer_transducer_epoch_5 filter=lfs diff=lfs merge=lfs -text

configs.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:71c80cb87c6609745efdb44813307a3773ed31375a02f16f24eff67f91631040
+size 973

inferences.py

@@ -0,0 +1,202 @@
+from typing import List, Optional, Tuple, Union
+
+import torch
+import torch.nn as nn
+from torch import Tensor
+from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence
+
+class MultiHeadAtt(nn.Module):
+    """A module that implements the multi-head attention mechanism described in
+    https://arxiv.org/abs/1706.03762.
+
+    Args:
+        d_model (int): The dimensionality of the model.
+
+        h (int): The number of heads to use in the attention mechanism.
+
+        masking_value (float, optional): The value used for masking. Defaults
+        to -1e15.
+    """
+
+    def __init__(self, d_model: int, h: int, masking_value: int = -1e15) -> None:
+        super().__init__()
+        self.h = h
+        self.dk = d_model // h
+        self.d_model = d_model
+        self.masking_value = masking_value
+        assert d_model % h == 0, ValueError
+        self.query_fc = nn.Linear(in_features=d_model, out_features=d_model)
+        self.key_fc = nn.Linear(in_features=d_model, out_features=d_model)
+        self.value_fc = nn.Linear(in_features=d_model, out_features=d_model)
+        self.softmax = nn.Softmax(dim=-1)
+
+    def _reshape(self, x: Tensor) -> List[Tensor]:
+        batch_size, max_len, _ = x.shape
+        x = x.view(batch_size, max_len, self.h, self.dk)
+        return x
+
+    def _mask(self, att: Tensor, key_mask: Tensor, query_mask: Tensor) -> Tensor:
+        key_max_len = key_mask.shape[-1]
+        query_max_len = query_mask.shape[-1]
+        key_mask = key_mask.repeat(1, query_max_len)
+        key_mask = key_mask.view(-1, query_max_len, key_max_len)
+        if query_mask.dim() != key_mask.dim():
+            query_mask = query_mask.unsqueeze(dim=-1)
+        mask = key_mask & query_mask
+        mask = mask.unsqueeze(dim=1)
+        return att.masked_fill(~mask, self.masking_value)
+
+    def perform_attention(
+        self,
+        key: Tensor,
+        query: Tensor,
+        value: Tensor,
+        key_mask: Optional[Tensor] = None,
+        query_mask: Optional[Tensor] = None,
+    ) -> Tensor:
+        """Performs multi-head attention by computing a weighted sum of the
+        values using queries and keys. The weights are computed as a softmax
+        over the dot products of the queries and keys for each attention head.
+        Optionally, attention can be masked using key and query masks.
+
+        Args:
+            key (Tensor): The key input tensor of shape [B, M, d]
+
+            query (Tensor): The query of shape [B, M, d]
+
+            value (Tensor): Teh value tensor of shape [B, M, d]
+
+            key_mask (Tensor, optional): A boolean tensor of shape
+            [B, M] where True indicates that the corresponding key position
+            contains data, not padding, and should not be masked
+
+            query_mask (Tensor, optional): A boolean tensor of shape
+            [B, M] where True indicates that the corresponding query position
+            contains data, not padding, and should not be masked
+
+        Returns:
+            Tensor: The tensor of shape [B, M, d] resulting from the multi-head
+            attention computation.
+        """
+        key = self._reshape(key)  # B, M, h, dk
+        query = self._reshape(query)  # B, M, h, dk
+        value = self._reshape(value)  # B, M, h, dk
+        key = key.permute(0, 2, 3, 1)  # B, h, dk, M
+        query = query.permute(0, 2, 1, 3)  # B, h, M, dk
+        value = value.permute(0, 2, 1, 3)  # B, h, M, dk
+        att = torch.matmul(query, key)
+        if key_mask is not None and query_mask is not None:
+            att = self._mask(att=att, key_mask=key_mask, query_mask=query_mask)
+        att = self.softmax(att / self.d_model)
+        out = torch.matmul(att, value)
+        out = out.permute(0, 2, 1, 3)
+        out = out.contiguous()
+        out = out.view(out.shape[0], out.shape[1], -1)
+        return out
+
+    def forward(
+        self,
+        key: Tensor,
+        query: Tensor,
+        value: Tensor,
+        key_mask: Union[Tensor, None] = None,
+        query_mask: Union[Tensor, None] = None,
+    ) -> Tensor:
+        """passes the input to the multi-head attention by computing a weighted
+        sum of the values using queries and keys. The weights are computed as a softmax
+        over the dot products of the queries and keys for each attention head.
+        Optionally, attention can be masked using key and query masks.
+
+        Args:
+            key (Tensor): The key input tensor of shape [B, M, d]
+
+            query (Tensor): The query of shape [B, M, d]
+
+            value (Tensor): Teh value tensor of shape [B, M, d]
+
+            key_mask (Tensor, optional): A boolean tensor of shape
+            [B, M] where True indicates that the corresponding key position
+            contains data, not padding, and should not be masked
+
+            query_mask (Tensor, optional): A boolean tensor of shape
+            [B, M] where True indicates that the corresponding query position
+            contains data, not padding, and should not be masked
+
+        Returns:
+            Tensor: The tensor of shape [B, M, d] resulting from the multi-head
+            attention computation.
+        """
+        key = self.key_fc(key)
+        query = self.query_fc(query)
+        value = self.value_fc(value)
+        return self.perform_attention(
+            key=key, query=query, value=value, key_mask=key_mask, query_mask=query_mask
+        )
+
+
+class TruncatedSelfAttention(MultiHeadAtt):
+    """Builds the truncated self attention module used
+    in https://arxiv.org/abs/1910.12977
+
+    Args:
+
+        d_model (int): The model dimension.
+
+        h (int): The number of attention heads.
+
+        left_size (int): The size of the left window that each time step is
+        allowed to look at.
+
+        right_size (int): The size of the right window that each time step is
+        allowed to look at.
+
+        masking_value (float): The attention masking value.
+    """
+
+    def __init__(
+        self,
+        d_model: int,
+        h: int,
+        left_size: int,
+        right_size: int,
+        masking_value: float = -1e15,
+    ) -> None:
+        super().__init__(d_model=d_model, h=h, masking_value=masking_value)
+        self.left_size = left_size
+        self.right_size = right_size
+
+    def get_looking_ahead_mask(self, mask: Tensor) -> Tensor:
+        truncated_mask = truncate_attention_mask(mask, self.right_size, self.left_size)
+        return truncated_mask
+
+    def _mask(self, att: Tensor, query_mask: Tensor, *args, **kwargs) -> Tensor:
+        query_mask = query_mask.unsqueeze(dim=1)
+        return att.masked_fill(~query_mask, self.masking_value)
+
+    def forward(
+        self,
+        x: Tensor,
+        mask: Union[Tensor, None],
+    ) -> Tensor:
+        """Applies truncated masked multi-head self attention to the input.
+
+        Args:
+
+            x (Tensor): The input tensor of shape [B, M, d].
+
+            mask (Union[Tensor, None]): The mask tensor of the input of shape
+            [B, M] where True indicates that the corresponding input position
+            contains data not padding and therefore should not be masked.
+            If None, the function will act as a normal multi-head self attention.
+
+        Returns:
+
+            Tensor: The attention result tensor of shape [B, M, d].
+
+        """
+        query_mask = None
+        if mask is not None:
+            query_mask = self.get_looking_ahead_mask(mask=mask)
+        return super().forward(
+            key=x, query=x, value=x, key_mask=mask, query_mask=query_mask
+        )

models.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5ca0e6aa7a827f32547647ec81b7d31b01887c7228b295be5babbc16843d5450
+size 29336

test.py

@@ -0,0 +1,58 @@
+import torch
+from utils.dataset import Speech2Text, speech_collate_fn
+from models.model import TransformerTransducer
+
+# ==== Load Dataset ====
+train_dataset = Speech2Text(
+    json_path="/home/anhkhoa/transformer_transducer/data/train.json",
+    vocab_path="/home/anhkhoa/transformer_transducer/data/vocab.json"
+)
+
+train_loader = torch.utils.data.DataLoader(
+    train_dataset,
+    batch_size=2,
+    shuffle=True,
+    collate_fn = speech_collate_fn
+)
+
+# ==== Kiểm tra 1 batch ====
+batch = next(iter(train_loader))
+
+# print("✅ Batch loaded!")
+# print("Fbank shape       :", batch['fbank'].shape)       # [B, T, 80]
+# print("Fbank lengths     :", batch['fbank_len'])          # [B]
+# print("Text shape        :", batch['text'].shape)         # [B, U]
+# print("Text lengths      :", batch['text_len'])           # [B]
+
+# ==== Load model (giả sử bạn có config) ====
+model = TransformerTransducer(
+    in_features=80,
+    n_classes=len(train_dataset.vocab),
+    n_layers=4,
+    n_dec_layers=2,
+    d_model=256,
+    ff_size=1024,
+    h=4,
+    joint_size=512,
+    enc_left_size=2,
+    enc_right_size=2,
+    dec_left_size=1,
+    dec_right_size=1,
+    p_dropout=0.1
+)
+
+def calculate_mask(lengths, max_len):
+    """Tạo mask cho các tensor có chiều dài khác nhau"""
+    mask = torch.arange(max_len, device=lengths.device)[None, :] < lengths[:, None]
+    return mask
+    
+
+with torch.no_grad():
+    output, fbank_len, text_len = model(
+        speech=batch["fbank"],           # [B, T, 80]
+        speech_mask=batch["fbank_mask"],         # [B, T]
+        text=batch["text"],              # [B, U]
+        text_mask=batch["text_mask"]            # [B, U]
+    )
+    
+print("✅ Model output shape:", output.shape)  # [B, T, U, vocab_size]

train (1).py

@@ -0,0 +1,171 @@
+import torch
+from utils.dataset import Speech2Text, speech_collate_fn
+from models.model import TransformerTransducer
+from tqdm import tqdm
+from models.loss import RNNTLoss
+import argparse
+import yaml
+import os 
+
+def train_one_epoch(model, dataloader, optimizer, criterion, device):
+    model.train()
+    total_loss = 0.0
+
+    progress_bar = tqdm(dataloader, desc="🔁 Training", leave=False)
+
+    for batch_idx, batch in enumerate(progress_bar):
+        speech = batch["fbank"].to(device)
+        text = batch["text"].to(device)
+        speech_mask = batch["fbank_mask"].to(device)
+        text_mask = batch["text_mask"].to(device)
+        fbank_len = batch["fbank_len"].to(device)
+        text_len = batch["text_len"].to(device)
+
+        optimizer.zero_grad()
+
+        output, _, _ = model(
+            speech=speech,
+            speech_mask=speech_mask,
+            text=text,
+            text_mask=text_mask,
+        )
+
+        # Bỏ <s> ở đầu nếu có
+        loss = criterion(output, text, fbank_len, text_len)
+        loss.backward()
+        optimizer.step()
+
+        total_loss += loss.item()
+
+        # === In loss từng batch ===
+        progress_bar.set_postfix(batch_loss=loss.item())
+
+    avg_loss = total_loss / len(dataloader)
+    print(f"✅ Average training loss: {avg_loss:.4f}")
+    return avg_loss
+
+
+from torchaudio.functional import rnnt_loss
+
+def evaluate(model, dataloader, criterion, device):
+    model.eval()
+    total_loss = 0.0
+
+    progress_bar = tqdm(dataloader, desc="🧪 Evaluating", leave=False)
+
+    with torch.no_grad():
+        for batch in progress_bar:
+            speech = batch["fbank"].to(device)
+            text = batch["text"].to(device)
+            speech_mask = batch["fbank_mask"].to(device)
+            text_mask = batch["text_mask"].to(device)
+            fbank_len = batch["fbank_len"].to(device)
+            text_len = batch["text_len"].to(device)
+
+            output, _, _ = model(
+                speech=speech,
+                speech_mask=speech_mask,
+                text=text,
+                text_mask=text_mask,
+            )
+
+            loss = criterion(output, text, fbank_len, text_len)
+            total_loss += loss.item()
+            progress_bar.set_postfix(batch_loss=loss.item())
+
+    avg_loss = total_loss / len(dataloader)
+    print(f"✅ Average validation loss: {avg_loss:.4f}")
+    return avg_loss
+
+def load_config(config_path):
+    with open(config_path, 'r') as f:
+        return yaml.safe_load(f)
+        
+def main():
+    from torch.optim import Adam
+    
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--config", type=str, required=True, help="Path to YAML config file")
+    args = parser.parse_args()
+
+    config = load_config(args.config)
+    training_cfg = config['training']
+    optimizer_cfg = config['optimizer']
+
+
+    # ==== Load Dataset ====
+    train_dataset = Speech2Text(
+        json_path=training_cfg['train_path'],
+        vocab_path=training_cfg['vocab_path'],
+    )
+
+    train_loader = torch.utils.data.DataLoader(
+        train_dataset,
+        batch_size= training_cfg['batch_size'],
+        shuffle=True,
+        collate_fn = speech_collate_fn
+    )
+
+    dev_dataset = Speech2Text(
+        json_path=training_cfg['dev_path'],
+        vocab_path=training_cfg['vocab_path']
+    )
+
+    dev_loader = torch.utils.data.DataLoader(
+        dev_dataset,
+        batch_size= training_cfg['batch_size'],
+        shuffle=True,
+        collate_fn = speech_collate_fn
+    )
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = TransformerTransducer(
+        in_features=config['model']['in_features'],
+        n_classes=len(train_dataset.vocab),
+        n_layers=config['model']['n_layers'],
+        n_dec_layers=config['model']['n_dec_layers'],
+        d_model=config['model']['d_model'],
+        ff_size=config['model']['ff_size'],
+        h=config['model']['h'],
+        joint_size=config['model']['joint_size'],
+        enc_left_size=config['model']['enc_left_size'],
+        enc_right_size=config['model']['enc_right_size'],
+        dec_left_size=config['model']['dec_left_size'],
+        dec_right_size=config['model']['dec_right_size'],
+        p_dropout=config['model']['p_dropout']
+    ).to(device)
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model.to(device)
+
+    # === Khởi tạo loss ===
+    # Giả sử <blank> = 0, và bạn chưa dùng reduction 'mean' toàn bộ batch
+    criterion = RNNTLoss(config["rnnt_loss"]["blank"] , config["rnnt_loss"]["reduction"])  # hoặc "sum" nếu bạn custom average
+
+    # === Optimizer ===
+    optimizer = Adam(model.parameters(), lr=optimizer_cfg['lr'])
+
+    # === Huấn luyện ===
+    num_epochs = config["training"]["epochs"]
+
+    for epoch in range(1, num_epochs + 1):
+        train_loss = train_one_epoch(model, train_loader, optimizer, criterion, device)
+        val_loss = evaluate(model,  dev_loader, criterion, device)
+
+        print(f"📘 Epoch {epoch}: Train Loss = {train_loss:.4f}, Val Loss = {val_loss:.4f}")
+        # Save model checkpoint
+
+        model_filename = os.path.join(
+            config['training']['save_path'],
+            f"transformer_transducer_epoch_{epoch}"
+        )
+
+        torch.save({
+            'epoch': epoch,
+            'model_state_dict': model.state_dict(),
+            'optimizer_state_dict': optimizer.state_dict(),
+        }, model_filename)
+
+
+if __name__ == "__main__":
+    main()

transformer_transducer_epoch_1

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:514df935f43f03013403f14e094bbd9203fb81193fdf84147df88296e63473ea
+size 760557182

transformer_transducer_epoch_2

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3a52a3614e4adab1b676f1d24a71bd0ca36c1b30fa7d70949f0ab6bc745f0485
+size 760557182

transformer_transducer_epoch_3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:afa7a15cc9cd2b973b6b08a50fb762b8a138e633121da27138588643a2773452
+size 760557182

transformer_transducer_epoch_4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:287ed73b2caccbfb91618e85d028795b09a7dd72484b89837bc7632c1f55b7d3
+size 760557182

transformer_transducer_epoch_5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:52c12064cccc1fcdb944eb26d5f3839989d3dd22357c628781542c19e2c34651
+size 760557182

utils.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3f1c016a65820bb3ae71241f84643343cc2e2bfb1f2876bccb13b85dbfbbd79c
+size 5552