pretrain.py

import torch
from torch.utils.data import Dataset, DataLoader
from tqdm import tqdm
import os
import glob
import wandb
from datasets import load_dataset
from accelerate import Accelerator
import argparse

from src.rwkv7 import RWKV7
from src.dataset import MyDataset
from src.transformer import TransformerModel

class L2Wrap(torch.autograd.Function):
    @staticmethod
    def forward(ctx, loss, y):
        ctx.save_for_backward(y)
        return loss

    @staticmethod
    def backward(ctx, grad_output):
        y = ctx.saved_tensors[0]
        factor = 1e-4 / (y.shape[0] * y.shape[1])
        maxx, ids = torch.max(y, -1, keepdim=True)
        gy = torch.zeros_like(y)
        gy.scatter_(-1, ids, maxx * factor)
        return grad_output, gy

def load_latest_checkpoint(model, checkpoint_dir):
    """
    Load the latest checkpoint for the model from the specified directory.
    
    Args:
        model: The model to load the checkpoint into
        checkpoint_dir: Directory containing checkpoint files (.pt)
    """
    checkpoint_files = [f for f in os.listdir(checkpoint_dir) if f.endswith('.pt')]
    if not checkpoint_files:
        print("No checkpoint files found in the directory.")
        return 0
    latest_checkpoint = max(checkpoint_files, key=lambda x: os.path.getctime(os.path.join(checkpoint_dir, x)))
    checkpoint_path = os.path.join(checkpoint_dir, latest_checkpoint)
    model.load_state_dict(torch.load(checkpoint_path))
    print(f"Loaded checkpoint: {checkpoint_path}")

def initialize_model(checkpoint_dir, dim, n_blocks):
    """
    Initialize the RWKV7 model and load the latest checkpoint.
    
    Args:
        checkpoint_dir: Directory containing checkpoint files
        dim: Dimension of the model
        n_blocks: Number of blocks in the model
    
    Returns:
        The initialized model
    """
    # Initialize model
    model = RWKV7(text_vocab=128, audio_vocab=8192 + 1, dim=dim, n_blocks=n_blocks).cuda()
    model = TransformerModel(text_vocab=128, audio_vocab=8192 + 1, dim=dim, n_blocks=n_blocks).cuda()
    # Load latest checkpoint
    load_latest_checkpoint(model, checkpoint_dir)
    
    # Print model statistics
    total_params = sum(p.numel() for p in model.parameters())
    trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
    print(f"Model total parameters: {total_params}")
    print(f"Model trainable parameters: {trainable_params}")
    
    return model

def collate_fn(batch):
    """
    Custom collate function for DataLoader to handle variable-length sequences.
    
    Args:
        batch: A batch of sequences
        
    Returns:
        Tuple of (input_ids, targets, loss_masks)
    """
    padding_token = 8192
    max_length = max(len(seq) for seq in batch) - 1  # Max length excluding the last token

    input_ids = []
    targets = []
    loss_masks = []

    for seq in batch:
        input_seq = list(seq[:-1])  # Input sequence, excluding the last token
        target_seq = list(seq[1:])  # Target sequence, starting from the second token
        input_padding = [padding_token] * (max_length - len(input_seq))
        target_padding = [padding_token] * (max_length - len(target_seq))
        mask_padding = [0] * (max_length - len(input_seq))

        input_ids.append(torch.tensor(input_seq + input_padding, dtype=torch.long))
        targets.append(torch.tensor(target_seq + target_padding, dtype=torch.long))
        loss_masks.append(torch.tensor([1] * len(input_seq) + mask_padding, dtype=torch.long))

    return torch.stack(input_ids, dim=0), torch.stack(targets, dim=0), torch.stack(loss_masks, dim=0)

def prepare_dataloader(batch_size):
    """
    Prepare dataset and dataloader.
    
    Args:
        batch_size: Batch size for training
        
    Returns:
        DataLoader for training
    """
    # Load dataset
    # dataset = load_dataset("JerryAGENDD/JLSpeech_tokenized", cache_dir="../temp_datasets")['train']
    dataset = load_dataset("./JLSpeech_tokenized")['train']
    dataset = MyDataset(hf_dataset=dataset, train_type='pretrain')
    
    # Create dataloader
    dataloader = DataLoader(
        dataset, 
        batch_size=batch_size, 
        shuffle=True, 
        collate_fn=collate_fn
    )
    
    return dataloader

def train(model, dataloader, num_epochs, output_dir, learning_rate):
    """
    Train the model.
    
    Args:
        model: The model to train
        dataloader: DataLoader for training data
        num_epochs: Number of training epochs
        output_dir: Directory to save checkpoints
        learning_rate: Learning rate for optimizer
    """
    # Set up accelerator and optimizer
    accelerator = Accelerator()
    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate,weight_decay=1e-4)
    model, dataloader, optimizer = accelerator.prepare(model, dataloader, optimizer)
    
    # Initialize wandb
    wandb.init(project="TTS")
    
    # Create output directory if it doesn't exist
    os.makedirs(output_dir, exist_ok=True)
    
    # Training loop
    model.train()
    for epoch in tqdm(range(num_epochs)):
        for batch in tqdm(dataloader, leave=False):
            input_ids, targets, loss_masks = batch
            input_ids = input_ids.long().to('cuda')
            targets = targets.long().to('cuda')
            loss_masks = loss_masks.to('cuda')

            # Forward pass
            outputs = model(None,None, input_ids)
            
            # Calculate loss
            criterion = torch.nn.CrossEntropyLoss(reduction='none')
            loss = criterion(outputs.view(-1, outputs.size(-1)), targets.view(-1))
            # Apply loss masks
            loss = loss.view(targets.size()) * loss_masks
            loss = loss.sum() / loss_masks.sum()  # Calculate average loss
            loss = L2Wrap.apply(loss, outputs)
            
            # Log to wandb
            wandb.log({"loss": loss.item()})
            
            # Backward pass and optimization
            optimizer.zero_grad()
            accelerator.backward(loss)
            optimizer.step()

        # Save checkpoint at the end of each epoch
        save_checkpoint(model, output_dir, epoch)
    
    # Finish the wandb run
    wandb.finish()

def save_checkpoint(model, output_dir, epoch):
    """
    Save a model checkpoint.
    
    Args:
        model: The model to save
        output_dir: Directory to save the checkpoint
        epoch: Current epoch number
    """
    # Delete all existing checkpoint files
    pt_files = glob.glob(os.path.join(output_dir, "*.pt"))
    for pt_file in pt_files:
        os.remove(pt_file)

    # Save current checkpoint
    checkpoint_path = os.path.join(output_dir, f"checkpoint_epoch_{epoch + 1}.pt")
    torch.save(model.state_dict(), checkpoint_path)
    # print(f"Saved checkpoint to {checkpoint_path}")

def main():
    """
        dim=256
        blocks=12

        learning_rate=1e-5
        num_epochs=4000
        batch_size=128

        export HF_ENDPOINT="https://hf-mirror.com" 
        python pretrain.py --dim $dim --n_blocks $blocks --learning_rate $learning_rate --num_epochs $num_epochs --batch_size $batch_size
    """
    import sys
    sys.argv.append( '--dim' )
    sys.argv.append( '256' )
    sys.argv.append( '--n_blocks' )
    sys.argv.append( '12' )
    sys.argv.append( '--learning_rate' )
    sys.argv.append( '1e-5' )
    sys.argv.append( '--num_epochs' )
    sys.argv.append( '4000' )
    sys.argv.append( '--batch_size' )
    sys.argv.append( '128' )

    parser = argparse.ArgumentParser(description="Train RWKV7 model")
    parser.add_argument("--dim", type=int, default=128, help="Dimension of the model")
    parser.add_argument("--n_blocks", type=int, default=5, help="Number of blocks in the model")
    parser.add_argument("--num_epochs", type=int, default=4000, help="Number of training epochs")
    parser.add_argument("--learning_rate", type=float, default=1e-4, help="Learning rate for optimizer")
    parser.add_argument("--batch_size", type=int, default=128, help="Batch size for training")
    args = parser.parse_args()

    # Configuration
    checkpoint_dir = "./checkpoints"
    
    # Initialize model
    model = initialize_model(checkpoint_dir, args.dim, args.n_blocks)
    
    # Prepare dataloader
    dataloader = prepare_dataloader(args.batch_size)
    
    # Train model
    train(model, dataloader, args.num_epochs, checkpoint_dir, args.learning_rate)

if __name__ == "__main__":
    main()