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 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, device): """ 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).to(device) # 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): # 分离文本和音频token id列表 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 # +1用于结束符 # 初始化填充后的列表和掩码 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): # 填充文本输入id并创建注意力掩码 padded_text = text + [text_pad_token] * (max_text_len - len(text)) attention_mask = [1] * len(text) + [0] * (max_text_len - len(text)) # 填充音频输入id并添加结束符 padded_audio = audio + [audio_pad_token] * (max_audio_len - len(audio) - 1) # 创建目标和损失掩码 target_seq = [0] * (len(text) - 1) + audio + [target_pad_token] * (max_audio_len + max_text_len - len(text) - len(audio)) loss_mask_seq = [0] * (len(text) - 1) + [1] * (len(audio) + 1) + [0] * (max_audio_len + max_text_len - len(text) - len(audio) - 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): """ 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("JerryAGENDD/libritts_tokenized_460", cache_dir="../temp_datasets")['train'] dataset = MyDataset(hf_dataset=dataset, train_type='sft') # 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, device): """ 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): text_input_ids, text_attention_mask, audio_input_ids, targets, loss_masks = batch text_input_ids = text_input_ids.long().to(device) text_attention_mask = text_attention_mask.to(device) audio_input_ids = audio_input_ids.long().to(device) targets = targets.long().to(device) loss_masks = loss_masks.to(device) # Forward pass outputs = model(text_input_ids, text_attention_mask, audio_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 test(): batch = [ ([1, 2, 3, 38], [100, 101, 102]), ([4, 5, 38], [103, 104, 105]), ([6, 7, 8, 9, 38], [106, 107, 108, 109, 110]) ] text_input_ids, text_attention_mask, audio_input_ids, target, loss_mask = collate_fn(batch) print(f"text_input_ids:{text_input_ids}") print(f"text_attention_mask:{text_attention_mask}") print(f"audio_input_ids:{audio_input_ids}") print(f"target:{target}") print(f"loss_mask:{loss_mask}") model = initialize_model("./checkpoints",320, 5, 'cuda:3') output = model(text_input_ids.long().to('cuda:3'), text_attention_mask.to('cuda:3'), audio_input_ids.long().to('cuda:3')) print(f"output:{output.shape}") return 0 def main(): """ Main function to run the training process. """ 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" device = torch.device("cuda:0") # Initialize model model = initialize_model(checkpoint_dir, args.dim, args.n_blocks, device) # Prepare dataloader dataloader = prepare_dataloader(args.batch_size) # Train model train(model, dataloader, args.num_epochs, checkpoint_dir, args.learning_rate, device) if __name__ == "__main__": main()