import os import torch from torch.nn import functional as F from torch.utils.data import DataLoader from torch.utils.tensorboard import SummaryWriter import torch.multiprocessing as mp import torch.distributed as dist from torch.nn.parallel import DistributedDataParallel as DDP from torch.cuda.amp import autocast, GradScaler from tqdm import tqdm import logging logging.getLogger("matplotlib").setLevel(logging.INFO) logging.getLogger("h5py").setLevel(logging.INFO) logging.getLogger("numba").setLevel(logging.INFO) from module import commons import utils from module.data_utils import ( TextAudioSpeakerLoader, TextAudioSpeakerCollate, DistributedBucketSampler ) from module.models_e2e import ( SynthesizerTrn, MultiPeriodDiscriminator, ) from module.losses import ( generator_loss, discriminator_loss, feature_loss, kl_loss ) from module.mel_processing import mel_spectrogram_torch, spec_to_mel_torch torch.backends.cudnn.benchmark = True global_step = 0 def main(): """Assume Single Node Multi GPUs Training Only""" assert torch.cuda.is_available(), "CPU training is not allowed." n_gpus = torch.cuda.device_count() os.environ['MASTER_ADDR'] = 'localhost' os.environ['MASTER_PORT'] = '8000' hps = utils.get_hparams(stage=2) mp.spawn(run, nprocs=n_gpus, args=(n_gpus, hps,)) import torch.nn as nn class ForwardSumLoss(nn.Module): def __init__(self, blank_logprob=-1): super().__init__() self.log_softmax = nn.LogSoftmax(dim=3) self.ctc_loss = nn.CTCLoss(zero_infinity=True) self.blank_logprob = blank_logprob def forward(self, attn_logprob, in_lens, out_lens): key_lens = in_lens query_lens = out_lens attn_logprob_padded = F.pad(input=attn_logprob, pad=(1, 0), value=self.blank_logprob) total_loss = 0.0 for bid in range(attn_logprob.shape[0]): target_seq = torch.arange(1, key_lens[bid] + 1).unsqueeze(0) curr_logprob = attn_logprob_padded[bid].permute(1, 0, 2)[: query_lens[bid], :, : key_lens[bid] + 1] curr_logprob = self.log_softmax(curr_logprob[None])[0] loss = self.ctc_loss( curr_logprob, target_seq, input_lengths=query_lens[bid : bid + 1], target_lengths=key_lens[bid : bid + 1], ) total_loss += loss total_loss /= attn_logprob.shape[0] return total_loss class BinLoss(nn.Module): def __init__(self): super().__init__() def forward(self, hard_attention, soft_attention): log_sum = torch.log(torch.clamp(soft_attention[hard_attention == 1], min=1e-12)).sum() return -log_sum / hard_attention.sum() def run(rank, n_gpus, hps): global global_step if rank == 0: logger = utils.get_logger(hps.s2_ckpt_dir) logger.info(hps) utils.check_git_hash(hps.s2_ckpt_dir) writer = SummaryWriter(log_dir=hps.s2_ckpt_dir) writer_eval = SummaryWriter(log_dir=os.path.join(hps.s2_ckpt_dir, "eval")) dist.init_process_group(backend='gloo' if os.name == 'nt' else 'nccl', init_method='env://', world_size=n_gpus, rank=rank) torch.manual_seed(hps.train.seed) torch.cuda.set_device(rank) train_dataset = TextAudioSpeakerLoader(hps.data.training_files, hps.data) train_sampler = DistributedBucketSampler( train_dataset, hps.train.batch_size, [32, 300, 400, 500, 600, 700, 800, 900, 1000], num_replicas=n_gpus, rank=rank, shuffle=True) collate_fn = TextAudioSpeakerCollate() train_loader = DataLoader(train_dataset, num_workers=6, shuffle=False, pin_memory=True, collate_fn=collate_fn, batch_sampler=train_sampler, persistent_workers=True) if rank == 0: eval_dataset = TextAudioSpeakerLoader(hps.data.validation_files, hps.data, val=True) eval_loader = DataLoader(eval_dataset, num_workers=0, shuffle=False, batch_size=1, pin_memory=True, drop_last=False, collate_fn=collate_fn) net_g = SynthesizerTrn( hps.data.filter_length // 2 + 1, hps.train.segment_size // hps.data.hop_length, n_speakers=hps.data.n_speakers, **hps.model).cuda(rank) net_d = MultiPeriodDiscriminator(hps.model.use_spectral_norm).cuda(rank) for name, param in net_g.named_parameters(): if not param.requires_grad: print(name,"not requires_grad") optim_g = torch.optim.AdamW( net_g.parameters(), hps.train.learning_rate, betas=hps.train.betas, eps=hps.train.eps) optim_d = torch.optim.AdamW( net_d.parameters(), hps.train.learning_rate, betas=hps.train.betas, eps=hps.train.eps) net_g = DDP(net_g, device_ids=[rank]) net_d = DDP(net_d, device_ids=[rank]) pretrain_dir = hps.pretrain if pretrain_dir is None: _, _, _, epoch_str = utils.load_checkpoint(utils.latest_checkpoint_path(hps.s2_ckpt_dir, "G_*.pth"), net_g, optim_g, False) _, _, _, epoch_str = utils.load_checkpoint(utils.latest_checkpoint_path(hps.s2_ckpt_dir, "D_*.pth"), net_d, optim_d, False) epoch_str = max(epoch_str, 1) global_step = (epoch_str - 1) * len(train_loader) else: _, _, _, epoch_str = utils.load_checkpoint(utils.latest_checkpoint_path(pretrain_dir, "G_*.pth"), net_g, optim_g, True) _, _, _, epoch_str = utils.load_checkpoint(utils.latest_checkpoint_path(pretrain_dir, "D_*.pth"), net_d, optim_d, True) epoch_str = 1 global_step = 0 if hps.resume_step != None: global_step = hps.resume_step scheduler_g = torch.optim.lr_scheduler.ExponentialLR(optim_g, gamma=hps.train.lr_decay, last_epoch=epoch_str - 2) scheduler_d = torch.optim.lr_scheduler.ExponentialLR(optim_d, gamma=hps.train.lr_decay, last_epoch=epoch_str - 2) scaler = GradScaler(enabled=hps.train.fp16_run) for epoch in range(epoch_str, hps.train.epochs + 1): if rank == 0: train_and_evaluate(rank, epoch, hps, [net_g, net_d], [optim_g, optim_d], [scheduler_g, scheduler_d], scaler, [train_loader, eval_loader], logger, [writer, writer_eval]) else: train_and_evaluate(rank, epoch, hps, [net_g, net_d], [optim_g, optim_d], [scheduler_g, scheduler_d], scaler, [train_loader, None], None, None) scheduler_g.step() scheduler_d.step() def train_and_evaluate(rank, epoch, hps, nets, optims, schedulers, scaler, loaders, logger, writers): net_g, net_d = nets optim_g, optim_d = optims scheduler_g, scheduler_d = schedulers train_loader, eval_loader = loaders if writers is not None: writer, writer_eval = writers train_loader.batch_sampler.set_epoch(epoch) global global_step sumLoss = ForwardSumLoss() binLoss = BinLoss() net_g.train() net_d.train() for batch_idx, (ssl, spec, spec_lengths, y, y_lengths, text, text_lengths, bert,spk_emb_padded,attn_priors) in tqdm(enumerate(train_loader)): spec, spec_lengths = spec.cuda(rank, non_blocking=True), spec_lengths.cuda(rank, non_blocking=True) y, y_lengths = y.cuda(rank, non_blocking=True), y_lengths.cuda(rank, non_blocking=True) ssl = ssl.cuda(rank, non_blocking=True) bert = bert.cuda(rank, non_blocking=True) text, text_lengths = text.cuda(rank, non_blocking=True), text_lengths.cuda(rank, non_blocking=True) attn_priors = attn_priors.cuda(rank, non_blocking=True) spk_emb_padded = spk_emb_padded.cuda(rank, non_blocking=True) with autocast(enabled=hps.train.fp16_run): mel = spec_to_mel_torch( spec, hps.data.filter_length, hps.data.n_mel_channels, hps.data.sampling_rate, hps.data.mel_fmin, hps.data.mel_fmax) y_hat, attn_out, ids_slice, x_mask, z_mask, \ (z, z_p, m_p, logs_p, m_q, logs_q), z_q, quantize_loss, dur_loss,prosody_predictor_loss = net_g(text, text_lengths, spec, spec_lengths,mel, ssl, attn_priors, bert, spk_emb_padded) y_mel = commons.slice_segments(mel, ids_slice, hps.train.segment_size // hps.data.hop_length) y_hat_mel = mel_spectrogram_torch( y_hat.squeeze(1), hps.data.filter_length, hps.data.n_mel_channels, hps.data.sampling_rate, hps.data.hop_length, hps.data.win_length, hps.data.mel_fmin, hps.data.mel_fmax ) y = commons.slice_segments(y, ids_slice * hps.data.hop_length, hps.train.segment_size) # slice # Discriminator y_d_hat_r, y_d_hat_g, _, _ = net_d(y, y_hat.detach()) with autocast(enabled=False): loss_disc, losses_disc_r, losses_disc_g = discriminator_loss(y_d_hat_r, y_d_hat_g) loss_disc_all = loss_disc optim_d.zero_grad() scaler.scale(loss_disc_all).backward() scaler.unscale_(optim_d) grad_norm_d = commons.clip_grad_value_(net_d.parameters(), None) scaler.step(optim_d) with autocast(enabled=hps.train.fp16_run): # Generator y_d_hat_r, y_d_hat_g, fmap_r, fmap_g = net_d(y, y_hat) with autocast(enabled=False): attn_soft, attn_hard, attn_hard_dur, attn_logprob = attn_out # Alignment loss ctc_loss = sumLoss(attn_logprob=attn_logprob, in_lens=text_lengths, out_lens=spec_lengths) binarization_loss_enable_steps = 0 binarization_loss_warmup_steps = 100 if global_step < binarization_loss_enable_steps: bin_loss_weight = 0. else: bin_loss_weight = min( (global_step - binarization_loss_enable_steps) / binarization_loss_warmup_steps, 1.0) * 1.0 bin_loss = binLoss(hard_attention=attn_hard, soft_attention=attn_soft) * bin_loss_weight loss_mel = F.l1_loss(y_mel, y_hat_mel) * hps.train.c_mel loss_kl = kl_loss(z_p, logs_q, m_p, logs_p, z_mask) * hps.train.c_kl loss_dur = torch.sum(dur_loss.float()) loss_fm = feature_loss(fmap_r, fmap_g) loss_gen, losses_gen = generator_loss(y_d_hat_g) loss_gen_all = loss_gen + loss_fm + loss_mel + loss_kl + quantize_loss + loss_dur + ctc_loss + bin_loss + prosody_predictor_loss *0.2 optim_g.zero_grad() scaler.scale(loss_gen_all).backward() scaler.unscale_(optim_g) grad_norm_g = commons.clip_grad_value_(net_g.parameters(), None) scaler.step(optim_g) scaler.update() if rank == 0: if global_step % hps.train.log_interval == 0: lr = optim_g.param_groups[0]['lr'] losses = [loss_disc, loss_gen, loss_fm, loss_mel, quantize_loss, loss_kl] logger.info('Train Epoch: {} [{:.0f}%]'.format( epoch, 100. * batch_idx / len(train_loader))) logger.info([x.item() for x in losses] + [global_step, lr]) scalar_dict = {"loss/g/total": loss_gen_all, "loss/d/total": loss_disc_all, "learning_rate": lr, "grad_norm_d": grad_norm_d, "grad_norm_g": grad_norm_g} scalar_dict.update( {"loss/g/fm": loss_fm, "loss/g/mel": loss_mel, "loss/g/kl": loss_kl, "loss/g/quantize_loss": quantize_loss,'dur_loss':loss_dur,"loss/g/bin": bin_loss, "loss/g/ctc": ctc_loss,"prosody_predictor_loss":prosody_predictor_loss}) # scalar_dict.update({"loss/g/{}".format(i): v for i, v in enumerate(losses_gen)}) # scalar_dict.update({"loss/d_r/{}".format(i): v for i, v in enumerate(losses_disc_r)}) # scalar_dict.update({"loss/d_g/{}".format(i): v for i, v in enumerate(losses_disc_g)}) attn_prior = attn_priors[0, :, :].squeeze().detach().cpu().numpy() # text_len x mel_len attn_soft = attn_soft[0, 0, :, :].detach().cpu().transpose(0, 1).numpy() # text_len x mel_len attn_hard = attn_hard[0, 0, :, :].detach().cpu().transpose(0, 1).numpy() # text_len x mel_len fig_attn = utils.plot_alignment( [ attn_soft, attn_hard, attn_prior, ], ["Soft Attention", "Hard Attention", "Prior"] ) image_dict = { "all/mel": utils.plot_spectrogram_to_numpy(mel[0].data.cpu().numpy()), "all/z_q": utils.plot_spectrogram_to_numpy(z_q[0].data.cpu().numpy()), "all/attn": fig_attn, } utils.summarize( writer=writer, global_step=global_step, images=image_dict, scalars=scalar_dict) if global_step % hps.train.eval_interval == 100 and global_step > 0: evaluate(hps, net_g, eval_loader, writer_eval) utils.save_checkpoint(net_g, optim_g, hps.train.learning_rate, epoch, os.path.join(hps.s2_ckpt_dir, "G_{}.pth".format(global_step))) utils.save_checkpoint(net_d, optim_d, hps.train.learning_rate, epoch, os.path.join(hps.s2_ckpt_dir, "D_{}.pth".format(global_step))) keep_ckpts = getattr(hps.train, 'keep_ckpts', 3) if keep_ckpts > 0: utils.clean_checkpoints(path_to_models=hps.s2_ckpt_dir, n_ckpts_to_keep=keep_ckpts, sort_by_time=True) global_step += 1 if rank == 0: logger.info('====> Epoch: {}'.format(epoch)) def evaluate(hps, generator, eval_loader, writer_eval): generator.eval() image_dict = {} audio_dict = {} print("Evaluating ...") with torch.no_grad(): for batch_idx, (ssl, spec, spec_lengths, y, y_lengths, text, text_lengths, bert,sid,attn_priors) in enumerate(eval_loader): print(111) spec, spec_lengths = spec.cuda(), spec_lengths.cuda() y, y_lengths = y.cuda(), y_lengths.cuda() ssl = ssl.cuda() text, text_lengths = text.cuda(), text_lengths.cuda() attn_priors = attn_priors.cuda() bert = bert.cuda() sid = sid.cuda() mel = spec_to_mel_torch( spec, hps.data.filter_length, hps.data.n_mel_channels, hps.data.sampling_rate, hps.data.mel_fmin, hps.data.mel_fmax) y_hat, mask, *_ = generator.module.reconstruct(text, text_lengths, spec, spec_lengths,mel, ssl,attn_priors, bert,sid, noise_scale=0.5) y_hat_lengths = mask.sum([1, 2]).long() * hps.data.hop_length y_hat_mel = mel_spectrogram_torch( y_hat.squeeze(1).float(), hps.data.filter_length, hps.data.n_mel_channels, hps.data.sampling_rate, hps.data.hop_length, hps.data.win_length, hps.data.mel_fmin, hps.data.mel_fmax ) image_dict.update({ f"gen/mel_{batch_idx}": utils.plot_spectrogram_to_numpy(y_hat_mel[0].cpu().numpy()) }) audio_dict.update({ f"gen/audio_{batch_idx}": y_hat[0, :, :] }) image_dict.update({f"gt/mel_{batch_idx}": utils.plot_spectrogram_to_numpy(mel[0].cpu().numpy())}) audio_dict.update({f"gt/audio_{batch_idx}": y[0, :, :]}) # y_hat, mask, *_ = generator.module.infer(ssl, spec_lengths, speakers, y=None) # audio_dict.update({ # f"gen/audio_{batch_idx}_style_pred": y_hat[0, :, :] # }) utils.summarize( writer=writer_eval, global_step=global_step, images=image_dict, audios=audio_dict, audio_sampling_rate=hps.data.sampling_rate ) generator.train() if __name__ == "__main__": main()