From 58a01dfc06a700b2799fe425a6b5fb1e79bded4e Mon Sep 17 00:00:00 2001 From: Ftps Date: Thu, 22 Jun 2023 01:20:26 +0900 Subject: [PATCH 1/5] Support mps and cpu in train --- train.py | 56 ++++++++++++++++++++++++++++++++------------------------ 1 file changed, 32 insertions(+), 24 deletions(-) diff --git a/train.py b/train.py index dba77bbb..d22fe829 100644 --- a/train.py +++ b/train.py @@ -17,7 +17,7 @@ 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.nn.parallel import DistributedDataParallel as DDP, DataParallel as DP from torch.cuda.amp import autocast, GradScaler import modules.commons as commons @@ -38,23 +38,29 @@ global_step = 0 start_time = time.time() +device = 'cuda' if torch.cuda.is_available() else 'mps' if torch.backends.mps.is_available() else 'cpu' + # os.environ['TORCH_DISTRIBUTED_DEBUG'] = 'INFO' def main(): """Assume Single Node Multi GPUs Training Only""" - assert torch.cuda.is_available(), "CPU training is not allowed." + assert torch.cuda.is_available() or torch.backends.mps.is_available(), "CPU training is not allowed." hps = utils.get_hparams() - n_gpus = torch.cuda.device_count() + n_gpus = torch.cuda.device_count() if torch.cuda.is_available() else 1 os.environ['MASTER_ADDR'] = 'localhost' os.environ['MASTER_PORT'] = hps.train.port - - mp.spawn(run, nprocs=n_gpus, args=(n_gpus, hps,)) + print("run") + if torch.cuda.is_available(): + mp.spawn(run, nprocs=n_gpus, args=(n_gpus, hps,)) + else: + run(0, n_gpus, hps) def run(rank, n_gpus, hps): global global_step + if rank == 0: logger = utils.get_logger(hps.model_dir) logger.info(hps) @@ -62,10 +68,11 @@ def run(rank, n_gpus, hps): writer = SummaryWriter(log_dir=hps.model_dir) writer_eval = SummaryWriter(log_dir=os.path.join(hps.model_dir, "eval")) - # for pytorch on win, backend use gloo - dist.init_process_group(backend= 'gloo' if os.name == 'nt' else 'nccl', init_method='env://', world_size=n_gpus, rank=rank) + # for pytorch on win, backend use gloo + dist.init_process_group(backend='gloo' if os.name == 'nt' or 'posix' else 'nccl', init_method='env://', world_size=n_gpus, rank=rank) torch.manual_seed(hps.train.seed) - torch.cuda.set_device(rank) + if torch.cuda.is_available(): + torch.cuda.set_device(rank) collate_fn = TextAudioCollate() all_in_mem = hps.train.all_in_mem # If you have enough memory, turn on this option to avoid disk IO and speed up training. train_dataset = TextAudioSpeakerLoader(hps.data.training_files, hps, all_in_mem=all_in_mem) @@ -83,8 +90,8 @@ def run(rank, n_gpus, hps): net_g = SynthesizerTrn( hps.data.filter_length // 2 + 1, hps.train.segment_size // hps.data.hop_length, - **hps.model).cuda(rank) - net_d = MultiPeriodDiscriminator(hps.model.use_spectral_norm).cuda(rank) + **hps.model).to(f'{device}:{rank}') + net_d = MultiPeriodDiscriminator(hps.model.use_spectral_norm).to(f'{device}:{rank}') optim_g = torch.optim.AdamW( net_g.parameters(), hps.train.learning_rate, @@ -95,8 +102,9 @@ def run(rank, n_gpus, hps): hps.train.learning_rate, betas=hps.train.betas, eps=hps.train.eps) - net_g = DDP(net_g, device_ids=[rank]) # , find_unused_parameters=True) - net_d = DDP(net_d, device_ids=[rank]) + rdp = DDP if torch.cuda.is_available() else DP + net_g = rdp(net_g, device_ids=[rank]) # , find_unused_parameters=True) + net_d = rdp(net_d, device_ids=[rank]) skip_optimizer = False try: @@ -156,12 +164,12 @@ def train_and_evaluate(rank, epoch, hps, nets, optims, schedulers, scaler, loade net_d.train() for batch_idx, items in enumerate(train_loader): c, f0, spec, y, spk, lengths, uv,volume = items - g = spk.cuda(rank, non_blocking=True) - spec, y = spec.cuda(rank, non_blocking=True), y.cuda(rank, non_blocking=True) - c = c.cuda(rank, non_blocking=True) - f0 = f0.cuda(rank, non_blocking=True) - uv = uv.cuda(rank, non_blocking=True) - lengths = lengths.cuda(rank, non_blocking=True) + g = spk.to(f'{device}:{rank}', non_blocking=True) + spec, y = spec.to(f'{device}:{rank}', non_blocking=True), y.to(f'{device}:{rank}', non_blocking=True) + c = c.to(f'{device}:{rank}', non_blocking=True) + f0 = f0.to(f'{device}:{rank}', non_blocking=True) + uv = uv.to(f'{device}:{rank}', non_blocking=True) + lengths = lengths.to(f'{device}:{rank}', non_blocking=True) mel = spec_to_mel_torch( spec, hps.data.filter_length, @@ -282,13 +290,13 @@ def evaluate(hps, generator, eval_loader, writer_eval): with torch.no_grad(): for batch_idx, items in enumerate(eval_loader): c, f0, spec, y, spk, _, uv,volume = items - g = spk[:1].cuda(0) - spec, y = spec[:1].cuda(0), y[:1].cuda(0) - c = c[:1].cuda(0) - f0 = f0[:1].cuda(0) - uv= uv[:1].cuda(0) + g = spk[:1].to(f'{device}:0') + spec, y = spec[:1].to(f'{device}:0'), y[:1].to(f'{device}:0') + c = c[:1].to(f'{device}:0') + f0 = f0[:1].to(f'{device}:0') + uv= uv[:1].to(f'{device}:0') if volume!=None: - volume = volume[:1].cuda(0) + volume = volume[:1].to(f'{device}:0') mel = spec_to_mel_torch( spec, hps.data.filter_length, From a4752a7f7a52aec6c12654c7c8bd7bde86bc5bb2 Mon Sep 17 00:00:00 2001 From: Ftps Date: Thu, 22 Jun 2023 01:25:05 +0900 Subject: [PATCH 2/5] Fix `!=None` to `not` --- train.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/train.py b/train.py index d22fe829..349bd295 100644 --- a/train.py +++ b/train.py @@ -295,7 +295,7 @@ def evaluate(hps, generator, eval_loader, writer_eval): c = c[:1].to(f'{device}:0') f0 = f0[:1].to(f'{device}:0') uv= uv[:1].to(f'{device}:0') - if volume!=None: + if not volume: volume = volume[:1].to(f'{device}:0') mel = spec_to_mel_torch( spec, From fd8885366154372fd43ce14ba9399c31b827c522 Mon Sep 17 00:00:00 2001 From: Ftps Date: Thu, 22 Jun 2023 01:25:30 +0900 Subject: [PATCH 3/5] Format --- train.py | 339 ++++++++++++++++++++++++++++++++++++++----------------- 1 file changed, 238 insertions(+), 101 deletions(-) diff --git a/train.py b/train.py index 349bd295..8ce805aa 100644 --- a/train.py +++ b/train.py @@ -2,8 +2,8 @@ import multiprocessing import time -logging.getLogger('matplotlib').setLevel(logging.WARNING) -logging.getLogger('numba').setLevel(logging.WARNING) +logging.getLogger("matplotlib").setLevel(logging.WARNING) +logging.getLogger("numba").setLevel(logging.WARNING) import os import json @@ -27,10 +27,7 @@ SynthesizerTrn, MultiPeriodDiscriminator, ) -from modules.losses import ( - kl_loss, - generator_loss, discriminator_loss, feature_loss -) +from modules.losses import kl_loss, generator_loss, discriminator_loss, feature_loss from modules.mel_processing import mel_spectrogram_torch, spec_to_mel_torch @@ -38,29 +35,44 @@ global_step = 0 start_time = time.time() -device = 'cuda' if torch.cuda.is_available() else 'mps' if torch.backends.mps.is_available() else 'cpu' +device = ( + "cuda" + if torch.cuda.is_available() + else "mps" + if torch.backends.mps.is_available() + else "cpu" +) # os.environ['TORCH_DISTRIBUTED_DEBUG'] = 'INFO' def main(): """Assume Single Node Multi GPUs Training Only""" - assert torch.cuda.is_available() or torch.backends.mps.is_available(), "CPU training is not allowed." + assert ( + torch.cuda.is_available() or torch.backends.mps.is_available() + ), "CPU training is not allowed." hps = utils.get_hparams() n_gpus = torch.cuda.device_count() if torch.cuda.is_available() else 1 - os.environ['MASTER_ADDR'] = 'localhost' - os.environ['MASTER_PORT'] = hps.train.port + os.environ["MASTER_ADDR"] = "localhost" + os.environ["MASTER_PORT"] = hps.train.port print("run") if torch.cuda.is_available(): - mp.spawn(run, nprocs=n_gpus, args=(n_gpus, hps,)) + mp.spawn( + run, + nprocs=n_gpus, + args=( + n_gpus, + hps, + ), + ) else: run(0, n_gpus, hps) def run(rank, n_gpus, hps): global global_step - + if rank == 0: logger = utils.get_logger(hps.model_dir) logger.info(hps) @@ -69,53 +81,87 @@ def run(rank, n_gpus, hps): writer_eval = SummaryWriter(log_dir=os.path.join(hps.model_dir, "eval")) # for pytorch on win, backend use gloo - dist.init_process_group(backend='gloo' if os.name == 'nt' or 'posix' else 'nccl', init_method='env://', world_size=n_gpus, rank=rank) + dist.init_process_group( + backend="gloo" if os.name == "nt" or "posix" else "nccl", + init_method="env://", + world_size=n_gpus, + rank=rank, + ) torch.manual_seed(hps.train.seed) if torch.cuda.is_available(): torch.cuda.set_device(rank) collate_fn = TextAudioCollate() - all_in_mem = hps.train.all_in_mem # If you have enough memory, turn on this option to avoid disk IO and speed up training. - train_dataset = TextAudioSpeakerLoader(hps.data.training_files, hps, all_in_mem=all_in_mem) + all_in_mem = ( + hps.train.all_in_mem + ) # If you have enough memory, turn on this option to avoid disk IO and speed up training. + train_dataset = TextAudioSpeakerLoader( + hps.data.training_files, hps, all_in_mem=all_in_mem + ) num_workers = 5 if multiprocessing.cpu_count() > 4 else multiprocessing.cpu_count() if all_in_mem: num_workers = 0 - train_loader = DataLoader(train_dataset, num_workers=num_workers, shuffle=False, pin_memory=True, - batch_size=hps.train.batch_size, collate_fn=collate_fn) + train_loader = DataLoader( + train_dataset, + num_workers=num_workers, + shuffle=False, + pin_memory=True, + batch_size=hps.train.batch_size, + collate_fn=collate_fn, + ) if rank == 0: - eval_dataset = TextAudioSpeakerLoader(hps.data.validation_files, hps, all_in_mem=all_in_mem,vol_aug = False) - eval_loader = DataLoader(eval_dataset, num_workers=1, shuffle=False, - batch_size=1, pin_memory=False, - drop_last=False, collate_fn=collate_fn) + eval_dataset = TextAudioSpeakerLoader( + hps.data.validation_files, hps, all_in_mem=all_in_mem, vol_aug=False + ) + eval_loader = DataLoader( + eval_dataset, + num_workers=1, + shuffle=False, + batch_size=1, + pin_memory=False, + drop_last=False, + collate_fn=collate_fn, + ) net_g = SynthesizerTrn( hps.data.filter_length // 2 + 1, hps.train.segment_size // hps.data.hop_length, - **hps.model).to(f'{device}:{rank}') - net_d = MultiPeriodDiscriminator(hps.model.use_spectral_norm).to(f'{device}:{rank}') + **hps.model, + ).to(f"{device}:{rank}") + net_d = MultiPeriodDiscriminator(hps.model.use_spectral_norm).to(f"{device}:{rank}") optim_g = torch.optim.AdamW( net_g.parameters(), hps.train.learning_rate, betas=hps.train.betas, - eps=hps.train.eps) + eps=hps.train.eps, + ) optim_d = torch.optim.AdamW( net_d.parameters(), hps.train.learning_rate, betas=hps.train.betas, - eps=hps.train.eps) + eps=hps.train.eps, + ) rdp = DDP if torch.cuda.is_available() else DP net_g = rdp(net_g, device_ids=[rank]) # , find_unused_parameters=True) net_d = rdp(net_d, device_ids=[rank]) skip_optimizer = False try: - _, _, _, epoch_str = utils.load_checkpoint(utils.latest_checkpoint_path(hps.model_dir, "G_*.pth"), net_g, - optim_g, skip_optimizer) - _, _, _, epoch_str = utils.load_checkpoint(utils.latest_checkpoint_path(hps.model_dir, "D_*.pth"), net_d, - optim_d, skip_optimizer) + _, _, _, epoch_str = utils.load_checkpoint( + utils.latest_checkpoint_path(hps.model_dir, "G_*.pth"), + net_g, + optim_g, + skip_optimizer, + ) + _, _, _, epoch_str = utils.load_checkpoint( + utils.latest_checkpoint_path(hps.model_dir, "D_*.pth"), + net_d, + optim_d, + skip_optimizer, + ) epoch_str = max(epoch_str, 1) - name=utils.latest_checkpoint_path(hps.model_dir, "D_*.pth") - global_step=int(name[name.rfind("_")+1:name.rfind(".")])+1 - #global_step = (epoch_str - 1) * len(train_loader) + name = utils.latest_checkpoint_path(hps.model_dir, "D_*.pth") + global_step = int(name[name.rfind("_") + 1 : name.rfind(".")]) + 1 + # global_step = (epoch_str - 1) * len(train_loader) except: print("load old checkpoint failed...") epoch_str = 1 @@ -125,8 +171,12 @@ def run(rank, n_gpus, hps): global_step = 0 warmup_epoch = hps.train.warmup_epochs - 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) + 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) @@ -134,22 +184,44 @@ def run(rank, n_gpus, hps): # set up warm-up learning rate if epoch <= warmup_epoch: for param_group in optim_g.param_groups: - param_group['lr'] = hps.train.learning_rate / warmup_epoch * epoch + param_group["lr"] = hps.train.learning_rate / warmup_epoch * epoch for param_group in optim_d.param_groups: - param_group['lr'] = hps.train.learning_rate / warmup_epoch * epoch + param_group["lr"] = hps.train.learning_rate / warmup_epoch * epoch # training 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]) + 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) + train_and_evaluate( + rank, + epoch, + hps, + [net_g, net_d], + [optim_g, optim_d], + [scheduler_g, scheduler_d], + scaler, + [train_loader, None], + None, + None, + ) # update learning rate scheduler_g.step() scheduler_d.step() -def train_and_evaluate(rank, epoch, hps, nets, optims, schedulers, scaler, loaders, logger, writers): +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 @@ -163,27 +235,47 @@ def train_and_evaluate(rank, epoch, hps, nets, optims, schedulers, scaler, loade net_g.train() net_d.train() for batch_idx, items in enumerate(train_loader): - c, f0, spec, y, spk, lengths, uv,volume = items - g = spk.to(f'{device}:{rank}', non_blocking=True) - spec, y = spec.to(f'{device}:{rank}', non_blocking=True), y.to(f'{device}:{rank}', non_blocking=True) - c = c.to(f'{device}:{rank}', non_blocking=True) - f0 = f0.to(f'{device}:{rank}', non_blocking=True) - uv = uv.to(f'{device}:{rank}', non_blocking=True) - lengths = lengths.to(f'{device}:{rank}', non_blocking=True) + c, f0, spec, y, spk, lengths, uv, volume = items + g = spk.to(f"{device}:{rank}", non_blocking=True) + spec, y = spec.to(f"{device}:{rank}", non_blocking=True), y.to( + f"{device}:{rank}", non_blocking=True + ) + c = c.to(f"{device}:{rank}", non_blocking=True) + f0 = f0.to(f"{device}:{rank}", non_blocking=True) + uv = uv.to(f"{device}:{rank}", non_blocking=True) + lengths = lengths.to(f"{device}:{rank}", non_blocking=True) 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) + hps.data.mel_fmax, + ) with autocast(enabled=hps.train.fp16_run): - y_hat, ids_slice, z_mask, \ - (z, z_p, m_p, logs_p, m_q, logs_q), pred_lf0, norm_lf0, lf0 = net_g(c, f0, uv, spec, g=g, c_lengths=lengths, - spec_lengths=lengths,vol = volume) + ( + y_hat, + ids_slice, + z_mask, + (z, z_p, m_p, logs_p, m_q, logs_q), + pred_lf0, + norm_lf0, + lf0, + ) = net_g( + c, + f0, + uv, + spec, + g=g, + c_lengths=lengths, + spec_lengths=lengths, + vol=volume, + ) - y_mel = commons.slice_segments(mel, ids_slice, hps.train.segment_size // hps.data.hop_length) + 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, @@ -192,15 +284,19 @@ def train_and_evaluate(rank, epoch, hps, nets, optims, schedulers, scaler, loade hps.data.hop_length, hps.data.win_length, hps.data.mel_fmin, - hps.data.mel_fmax + hps.data.mel_fmax, ) - y = commons.slice_segments(y, ids_slice * hps.data.hop_length, hps.train.segment_size) # slice + 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, 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() @@ -228,58 +324,97 @@ def train_and_evaluate(rank, epoch, hps, nets, optims, schedulers, scaler, loade if rank == 0: if global_step % hps.train.log_interval == 0: - lr = optim_g.param_groups[0]['lr'] + lr = optim_g.param_groups[0]["lr"] losses = [loss_disc, loss_gen, loss_fm, loss_mel, loss_kl] - reference_loss=0 + reference_loss = 0 for i in losses: reference_loss += i - logger.info('Train Epoch: {} [{:.0f}%]'.format( - epoch, - 100. * batch_idx / len(train_loader))) - logger.info(f"Losses: {[x.item() for x in losses]}, step: {global_step}, lr: {lr}, reference_loss: {reference_loss}") + logger.info( + "Train Epoch: {} [{:.0f}%]".format( + epoch, 100.0 * batch_idx / len(train_loader) + ) + ) + logger.info( + f"Losses: {[x.item() for x in losses]}, step: {global_step}, lr: {lr}, reference_loss: {reference_loss}" + ) - 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/lf0": loss_lf0}) + 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/lf0": loss_lf0, + } + ) # 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)}) image_dict = { - "slice/mel_org": utils.plot_spectrogram_to_numpy(y_mel[0].data.cpu().numpy()), - "slice/mel_gen": utils.plot_spectrogram_to_numpy(y_hat_mel[0].data.cpu().numpy()), - "all/mel": utils.plot_spectrogram_to_numpy(mel[0].data.cpu().numpy()), - "all/lf0": utils.plot_data_to_numpy(lf0[0, 0, :].cpu().numpy(), - pred_lf0[0, 0, :].detach().cpu().numpy()), - "all/norm_lf0": utils.plot_data_to_numpy(lf0[0, 0, :].cpu().numpy(), - norm_lf0[0, 0, :].detach().cpu().numpy()) + "slice/mel_org": utils.plot_spectrogram_to_numpy( + y_mel[0].data.cpu().numpy() + ), + "slice/mel_gen": utils.plot_spectrogram_to_numpy( + y_hat_mel[0].data.cpu().numpy() + ), + "all/mel": utils.plot_spectrogram_to_numpy( + mel[0].data.cpu().numpy() + ), + "all/lf0": utils.plot_data_to_numpy( + lf0[0, 0, :].cpu().numpy(), + pred_lf0[0, 0, :].detach().cpu().numpy(), + ), + "all/norm_lf0": utils.plot_data_to_numpy( + lf0[0, 0, :].cpu().numpy(), + norm_lf0[0, 0, :].detach().cpu().numpy(), + ), } utils.summarize( writer=writer, global_step=global_step, images=image_dict, - scalars=scalar_dict + scalars=scalar_dict, ) if global_step % hps.train.eval_interval == 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.model_dir, "G_{}.pth".format(global_step))) - utils.save_checkpoint(net_d, optim_d, hps.train.learning_rate, epoch, - os.path.join(hps.model_dir, "D_{}.pth".format(global_step))) - keep_ckpts = getattr(hps.train, 'keep_ckpts', 0) + utils.save_checkpoint( + net_g, + optim_g, + hps.train.learning_rate, + epoch, + os.path.join(hps.model_dir, "G_{}.pth".format(global_step)), + ) + utils.save_checkpoint( + net_d, + optim_d, + hps.train.learning_rate, + epoch, + os.path.join(hps.model_dir, "D_{}.pth".format(global_step)), + ) + keep_ckpts = getattr(hps.train, "keep_ckpts", 0) if keep_ckpts > 0: - utils.clean_checkpoints(path_to_models=hps.model_dir, n_ckpts_to_keep=keep_ckpts, sort_by_time=True) + utils.clean_checkpoints( + path_to_models=hps.model_dir, + n_ckpts_to_keep=keep_ckpts, + sort_by_time=True, + ) global_step += 1 if rank == 0: global start_time now = time.time() - durtaion = format(now - start_time, '.2f') - logger.info(f'====> Epoch: {epoch}, cost {durtaion} s') + durtaion = format(now - start_time, ".2f") + logger.info(f"====> Epoch: {epoch}, cost {durtaion} s") start_time = now @@ -289,22 +424,23 @@ def evaluate(hps, generator, eval_loader, writer_eval): audio_dict = {} with torch.no_grad(): for batch_idx, items in enumerate(eval_loader): - c, f0, spec, y, spk, _, uv,volume = items - g = spk[:1].to(f'{device}:0') - spec, y = spec[:1].to(f'{device}:0'), y[:1].to(f'{device}:0') - c = c[:1].to(f'{device}:0') - f0 = f0[:1].to(f'{device}:0') - uv= uv[:1].to(f'{device}:0') + c, f0, spec, y, spk, _, uv, volume = items + g = spk[:1].to(f"{device}:0") + spec, y = spec[:1].to(f"{device}:0"), y[:1].to(f"{device}:0") + c = c[:1].to(f"{device}:0") + f0 = f0[:1].to(f"{device}:0") + uv = uv[:1].to(f"{device}:0") if not volume: - volume = volume[:1].to(f'{device}:0') + volume = volume[:1].to(f"{device}:0") 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,_ = generator.module.infer(c, f0, uv, g=g,vol = volume) + hps.data.mel_fmax, + ) + y_hat, _ = generator.module.infer(c, f0, uv, g=g, vol=volume) y_hat_mel = mel_spectrogram_torch( y_hat.squeeze(1).float(), @@ -314,23 +450,24 @@ def evaluate(hps, generator, eval_loader, writer_eval): hps.data.hop_length, hps.data.win_length, hps.data.mel_fmin, - hps.data.mel_fmax + hps.data.mel_fmax, ) - audio_dict.update({ - f"gen/audio_{batch_idx}": y_hat[0], - f"gt/audio_{batch_idx}": y[0] - }) - image_dict.update({ - f"gen/mel": utils.plot_spectrogram_to_numpy(y_hat_mel[0].cpu().numpy()), - "gt/mel": utils.plot_spectrogram_to_numpy(mel[0].cpu().numpy()) - }) + audio_dict.update( + {f"gen/audio_{batch_idx}": y_hat[0], f"gt/audio_{batch_idx}": y[0]} + ) + image_dict.update( + { + f"gen/mel": utils.plot_spectrogram_to_numpy(y_hat_mel[0].cpu().numpy()), + "gt/mel": utils.plot_spectrogram_to_numpy(mel[0].cpu().numpy()), + } + ) utils.summarize( writer=writer_eval, global_step=global_step, images=image_dict, audios=audio_dict, - audio_sampling_rate=hps.data.sampling_rate + audio_sampling_rate=hps.data.sampling_rate, ) generator.train() From 77bedaa868059a25bacbea01c5b947605f2b8c80 Mon Sep 17 00:00:00 2001 From: Ftps Date: Thu, 22 Jun 2023 01:32:52 +0900 Subject: [PATCH 4/5] remove assert --- train.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/train.py b/train.py index 8ce805aa..79661d42 100644 --- a/train.py +++ b/train.py @@ -48,9 +48,6 @@ def main(): """Assume Single Node Multi GPUs Training Only""" - assert ( - torch.cuda.is_available() or torch.backends.mps.is_available() - ), "CPU training is not allowed." hps = utils.get_hparams() n_gpus = torch.cuda.device_count() if torch.cuda.is_available() else 1 From 5eb748b30d852f95d9f35c3906690afbd2ddde64 Mon Sep 17 00:00:00 2001 From: Ftps Date: Thu, 22 Jun 2023 10:35:42 +0900 Subject: [PATCH 5/5] Delete unnecessary line and add comments --- train.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/train.py b/train.py index 79661d42..341ac1da 100644 --- a/train.py +++ b/train.py @@ -47,13 +47,12 @@ def main(): - """Assume Single Node Multi GPUs Training Only""" hps = utils.get_hparams() n_gpus = torch.cuda.device_count() if torch.cuda.is_available() else 1 os.environ["MASTER_ADDR"] = "localhost" os.environ["MASTER_PORT"] = hps.train.port - print("run") + if torch.cuda.is_available(): mp.spawn( run, @@ -77,7 +76,7 @@ def run(rank, n_gpus, hps): writer = SummaryWriter(log_dir=hps.model_dir) writer_eval = SummaryWriter(log_dir=os.path.join(hps.model_dir, "eval")) - # for pytorch on win, backend use gloo + # for pytorch on win and mac, backend use gloo dist.init_process_group( backend="gloo" if os.name == "nt" or "posix" else "nccl", init_method="env://",