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'] = '80000' hps = utils.get_hparams() mp.spawn(train_and_eval, nprocs=n_gpus, args=(n_gpus, hps,))
def main(): hps = utils.get_hparams() logger = utils.get_logger(hps.model_dir) logger.info(hps) utils.check_git_hash(hps.model_dir) torch.manual_seed(hps.train.seed) train_dataset = TextMelLoader(hps.data.training_files, hps.data) collate_fn = TextMelCollate(1) train_loader = DataLoader(train_dataset, num_workers=8, shuffle=True, batch_size=hps.train.batch_size, pin_memory=True, drop_last=True, collate_fn=collate_fn) generator = FlowGenerator_DDI(speaker_dim=hps.model.speaker_embedding, n_vocab=len(symbols), out_channels=hps.data.n_mel_channels, **hps.model).cuda() optimizer_g = commons.Adam(generator.parameters(), scheduler=hps.train.scheduler, dim_model=hps.model.hidden_channels, warmup_steps=hps.train.warmup_steps, lr=hps.train.learning_rate, betas=hps.train.betas, eps=hps.train.eps) generator.train() for batch_idx, (x, x_lengths, y, y_lengths, speaker_embedding) in enumerate(train_loader): x, x_lengths = x.cuda(), x_lengths.cuda() y, y_lengths = y.cuda(), y_lengths.cuda() speaker_embedding = speaker_embedding.cuda() _ = generator(x, x_lengths, speaker_embedding, y, y_lengths, gen=False) break utils.save_checkpoint(generator, optimizer_g, hps.train.learning_rate, 0, os.path.join(hps.model_dir, "ddi_G.pth"))
def main(): # list of hparams to test optimizer_list = ['adam', 'sgd'] num_units_list = [32, 128] dropout_list = [0.0, 0.4, 0.8] exp_summary = create_experiment_summary(optimizer_list, num_units_list, dropout_list) root_writer = tf.summary.create_file_writer('runs/tuning') with root_writer.as_default(): tf.summary.import_event( tf.compat.v1.Event(summary=exp_summary).SerializeToString()) run = 0 for optimizer in optimizer_list: for num_units in num_units_list: for dropout in dropout_list: hparams = get_hparams( num_units=num_units, optimizer=optimizer, dropout=dropout, run=run) print_run_info(hparams) train_and_test(hparams) run += 1
def main(): hparams = get_hparams() datasets = get_dataset(hparams) model = keras.models.Sequential([ keras.layers.Flatten(), keras.layers.Dense(hparams.num_units, activation='relu'), keras.layers.Dropout(hparams.dropout), keras.layers.Dense(hparams.num_units, activation='relu'), keras.layers.Dropout(hparams.dropout), keras.layers.Dense(hparams.num_classes, activation='softmax') ]) optimizer = get_optimizer(hparams) model.compile(optimizer=optimizer, loss='sparse_categorical_crossentropy', metrics=['accuracy']) model.fit(x=datasets['train'], y=None, epochs=hparams.epochs, validation_data=datasets['test'])
def main(): hps = utils.get_hparams() logger = utils.get_logger(hps.model_dir) logger.info(hps) utils.check_git_hash(hps.model_dir) torch.manual_seed(hps.train.seed) train_dataset = TextMelLoader(hps.data.training_files, hps.data) collate_fn = TextMelCollate(1) train_loader = DataLoader(train_dataset, num_workers=8, shuffle=True, batch_size=hps.train.batch_size, pin_memory=True, drop_last=True, collate_fn=collate_fn) generator = FlowGenerator_DDI( len(symbols), out_channels=hps.data.n_mel_channels, **hps.model).cuda() optimizer_g = commons.Adam(generator.parameters(), scheduler=hps.train.scheduler, dim_model=hps.model.hidden_channels, warmup_steps=hps.train.warmup_steps, lr=hps.train.learning_rate, betas=hps.train.betas, eps=hps.train.eps) generator.train() for batch_idx, (x, x_lengths, y, y_lengths) in enumerate(train_loader): x, x_lengths = x.cuda(), x_lengths.cuda() y, y_lengths = y.cuda(), y_lengths.cuda() _ = generator(x, x_lengths, y, y_lengths, gen=False) break # check for pretrained and load it without a an optimizer pretrained_checkpoint_path = os.path.join(hps.model_dir, "pretrained.pth") if os.path.isfile(pretrained_checkpoint_path): logger.info("Loading pretrained checkpoint: %s" % pretrained_checkpoint_path) model, optimizer, learning_rate, iteration = utils.load_checkpoint(pretrained_checkpoint_path, generator) utils.save_checkpoint(model, optimizer_g, hps.train.learning_rate, 0, os.path.join(hps.model_dir, "ddi_G.pth")) else: utils.save_checkpoint(generator, optimizer_g, hps.train.learning_rate, 0, os.path.join(hps.model_dir, "ddi_G.pth"))
import os import json import argparse import torch from torch import nn, optim from torch.nn import functional as F from torch.utils.data import DataLoader from data import LJspeechDataset, collate_fn, collate_fn_synthesize import models import commons import utils hps = utils.get_hparams() logger = utils.get_logger(hps.model_dir) logger.info(hps) utils.check_git_hash(hps.model_dir) use_cuda = hps.train.use_cuda and torch.cuda.is_available() torch.manual_seed(hps.train.seed) device = torch.device("cuda" if use_cuda else "cpu") kwargs = {'num_workers': 8, 'pin_memory': True} if use_cuda else {} train_dataset = LJspeechDataset(hps.data.data_path, True, 0.1) test_dataset = LJspeechDataset(hps.data.data_path, False, 0.1) train_loader = DataLoader(train_dataset, batch_size=hps.train.batch_size, shuffle=True, collate_fn=collate_fn, **kwargs) test_loader = DataLoader(test_dataset,
def main(): hparams = get_hparams(output_root='runs/custom') train_and_test(hparams)
def main(): hparams = get_hparams() train_and_eval(hparams)