posttrain_multiGPU.py

import torch
from torch.utils.data import Dataset, DataLoader, DistributedSampler
from tqdm import tqdm
import os
import glob
import wandb
from datasets import load_dataset, concatenate_datasets
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP
import argparse

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

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 setup(rank, world_size):
    os.environ['MASTER_ADDR'] = 'localhost'
    os.environ['MASTER_PORT'] = '12355'
    dist.init_process_group("nccl", rank=rank, world_size=world_size)
    torch.cuda.set_device(rank)

def cleanup():
    dist.destroy_process_group()

def load_latest_checkpoint(model, checkpoint_dir):
    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, rank, world_size):
    model = RWKV7(text_vocab=128, audio_vocab=8192 + 1, dim=dim, n_blocks=n_blocks).to(rank)
    # model = TransformerModel(text_vocab=128, audio_vocab=8192 + 1, dim=dim, n_blocks=n_blocks).to(rank)
    
    if rank == 0:
        load_latest_checkpoint(model, checkpoint_dir)
    dist.barrier()
    model = DDP(model, device_ids=[rank],find_unused_parameters=True, broadcast_buffers=False)
    
    # 从 rank 0 广播模型状态到所有其他 rank
    for param in model.parameters():
        dist.broadcast(param.data.clone(), src=0)  # 使用 clone() 方法
    
    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):
    text_token_ids = [item[0] for item in batch]
    audio_token_ids = [item[1] for item in batch]
    max_text_len = max(len(text) for text in text_token_ids)
    max_audio_len = max(len(audio) for audio in audio_token_ids) + 1
    chunck_length = (((max_text_len+max_audio_len) // 16) + 1) * 16
    
    text_input_ids, text_attention_mask, audio_input_ids, target, loss_mask = [], [], [], [], []
    text_pad_token = 38
    audio_pad_token = 8192
    target_pad_token = 8192
    
    for text, audio in zip(text_token_ids, audio_token_ids):
        padded_text = text + [text_pad_token] * (max_text_len - len(text))
        attention_mask = [1] * len(text) + [0] * (max_text_len - len(text))
        padded_audio = audio + [audio_pad_token] * (max_audio_len - len(audio) - 1) + [audio_pad_token] * (chunck_length - max_text_len - max_audio_len + 1)
        target_seq = [0] * (len(text) - 1) + audio + [target_pad_token] * (max_audio_len + max_text_len - len(text) - len(audio)) + [target_pad_token] * (chunck_length - max_text_len - max_audio_len + 1)
        loss_mask_seq = [0] * (len(text) - 1) + [1] * (len(audio) + 1) + [0] * (max_audio_len + max_text_len - len(text) - len(audio) - 1) + [0] * (chunck_length - max_text_len - max_audio_len+1)
        text_input_ids.append(padded_text)
        text_attention_mask.append(attention_mask)
        audio_input_ids.append(padded_audio)
        target.append(target_seq)
        loss_mask.append(loss_mask_seq)
        
    return torch.tensor(text_input_ids), torch.tensor(text_attention_mask), torch.tensor(audio_input_ids), torch.tensor(target), torch.tensor(loss_mask)

def prepare_dataloader(batch_size, rank, world_size):
    # dataset = load_dataset("JerryAGENDD/JLSpeech_tokenized", cache_dir="../temp_datasets")['train']
    # dataset = dataset.remove_columns(['text', 'audio'])
    # dataset = dataset.rename_column("normalized_text", "text_normalized")
    
    dataset2 = load_dataset("JerryAGENDD/libritts_tokenized_960", cache_dir="../temp_datasets")['train']
    dataset = dataset2.remove_columns(['text_original', 'speaker_id'])
    
    # dataset = concatenate_datasets([dataset, dataset2]).shuffle()

    dataset = MyDataset(hf_dataset=dataset, train_type='sft')
    sampler = DistributedSampler(dataset, num_replicas=world_size, rank=rank, shuffle=True)
    dataloader = DataLoader(dataset, batch_size=batch_size, sampler=sampler, collate_fn=collate_fn)
    return dataloader

def train(rank, world_size, args):
    setup(rank, world_size)
    model = initialize_model(args.checkpoint_dir, args.dim, args.n_blocks, rank,world_size)
    dataloader = prepare_dataloader(args.batch_size, rank, world_size)
    optimizer = torch.optim.Adam(model.parameters(), lr=args.learning_rate, weight_decay=1e-4)
    
    if rank == 0:
        wandb.init(project="TTS")
    logging_parameter = True
    os.makedirs(args.checkpoint_dir, exist_ok=True)
    model.train()
    for epoch in range(args.num_epochs):
        dataloader.sampler.set_epoch(epoch)
        if rank == 0:
            epoch_iterator = tqdm(dataloader, desc=f"Epoch {epoch + 1}/{args.num_epochs}", leave=False)
        else:
            epoch_iterator = dataloader
        
        for batch in epoch_iterator:
            text_input_ids, text_attention_mask, audio_input_ids, targets, loss_masks = batch
            text_input_ids = text_input_ids.long().to(rank)
            text_attention_mask = text_attention_mask.to(rank)
            audio_input_ids = audio_input_ids.long().to(rank)
            targets = targets.long().to(rank)
            loss_masks = loss_masks.to(rank)
            outputs = model(text_input_ids, text_attention_mask, audio_input_ids)
            criterion = torch.nn.CrossEntropyLoss(reduction='none')
            loss = criterion(outputs.view(-1, outputs.size(-1)), targets.view(-1))
            loss = loss.view(targets.size()) * loss_masks
            loss = loss.sum() / loss_masks.sum()
            loss = L2Wrap.apply(loss, outputs)
            
            if rank == 0:
                wandb.log({"loss": loss.item()})
            
            optimizer.zero_grad()
            loss.backward()
            
            if(logging_parameter and rank == 0):
                for name, param in model.named_parameters():
                    if param.grad is None:
                        print(f"Parameter {name} did not receive gradient")

                logging_parameter = False
            
            optimizer.step()
        
        if rank == 0:
            save_checkpoint(model, args.checkpoint_dir, epoch)
    
    if rank == 0:
        wandb.finish()
    
    cleanup()

def save_checkpoint(model, output_dir, epoch):
    pt_files = glob.glob(os.path.join(output_dir, "*.pt"))
    for pt_file in pt_files:
        os.remove(pt_file)
    checkpoint_path = os.path.join(output_dir, f"checkpoint_epoch_{epoch + 1}.pt")
    torch.save(model.module.state_dict(), checkpoint_path)

def main():
    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")
    parser.add_argument("--checkpoint_dir", type=str, default="./checkpoints", help="Directory to save checkpoints")
    args = parser.parse_args()
    world_size = torch.cuda.device_count()
    torch.multiprocessing.spawn(train, args=(world_size, args), nprocs=world_size, join=True)

if __name__ == "__main__":
    main()