def test():
checkpoint = 'tacotron2-cn.pt'
print('loading model: {}...'.format(checkpoint))
model = Tacotron2(HParams())
model.load_state_dict(torch.load(checkpoint))
model = model.to('cpu')
model.eval()
print(bcolors.HEADER + '\nPost-training static quantization' +
bcolors.ENDC)
num_calibration_batches = 10
model.qconfig = torch.quantization.default_qconfig
print(model.qconfig)
torch.quantization.prepare(model, inplace=True)
# Calibrate first
print('Post Training Quantization Prepare: Inserting Observers')
# Calibrate with the training set
print('Calibrate with the training set')
evaluate(model, neval_batches=num_calibration_batches)
print('Post Training Quantization: Calibration done')
# Convert to quantized model
torch.quantization.convert(model, inplace=True)
print('Post Training Quantization: Convert done')
print("Size of model after quantization")
print_size_of_model(model)
def train_net(args):
torch.manual_seed(7)
np.random.seed(7)
checkpoint = args.checkpoint
start_epoch = 0
best_loss = float('inf')
writer = SummaryWriter()
epochs_since_improvement = 0
# Initialize / load checkpoint
if checkpoint is None:
# model
model = Tacotron2(config)
print(model)
# model = nn.DataParallel(model)
# optimizer
optimizer = Tacotron2Optimizer(
torch.optim.Adam(model.parameters(),
lr=args.lr,
weight_decay=args.l2,
betas=(0.9, 0.999),
eps=1e-6))
else:
checkpoint = torch.load(checkpoint)
start_epoch = checkpoint['epoch'] + 1
epochs_since_improvement = checkpoint['epochs_since_improvement']
model = checkpoint['model']
optimizer = checkpoint['optimizer']
logger = get_logger()
# Move to GPU, if available
model = model.to(config.device)
criterion = Tacotron2Loss()
collate_fn = TextMelCollate(config.n_frames_per_step)
# Custom dataloaders
train_dataset = TextMelLoader(config.training_files, config)
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=args.batch_size,
collate_fn=collate_fn,
pin_memory=True,
shuffle=True,
num_workers=args.num_workers)
valid_dataset = TextMelLoader(config.validation_files, config)
valid_loader = torch.utils.data.DataLoader(valid_dataset,
batch_size=args.batch_size,
collate_fn=collate_fn,
pin_memory=True,
shuffle=False,
num_workers=args.num_workers)
# Epochs
for epoch in range(start_epoch, args.epochs):
# One epoch's training
train_loss = train(train_loader=train_loader,
model=model,
optimizer=optimizer,
criterion=criterion,
epoch=epoch,
logger=logger)
writer.add_scalar('model/train_loss', train_loss, epoch)
lr = optimizer.lr
print('\nLearning rate: {}'.format(lr))
writer.add_scalar('model/learning_rate', lr, epoch)
step_num = optimizer.step_num
print('Step num: {}\n'.format(step_num))
# One epoch's validation
valid_loss = valid(valid_loader=valid_loader,
model=model,
criterion=criterion,
logger=logger)
writer.add_scalar('model/valid_loss', valid_loss, epoch)
# Check if there was an improvement
is_best = valid_loss < best_loss
best_loss = min(valid_loss, best_loss)
if not is_best:
epochs_since_improvement += 1
print("\nEpochs since last improvement: %d\n" %
(epochs_since_improvement, ))
else:
epochs_since_improvement = 0
# Save checkpoint
save_checkpoint(epoch, epochs_since_improvement, model, optimizer,
best_loss, is_best)
# alignments
img_align = test(model, optimizer.step_num, valid_loss)
writer.add_image('model/alignment',
img_align,
epoch,
dataformats='HWC')
self.register_buffer('bias_spec', bias_spec[:, :, 0][:, :, None])
def forward(self, audio, strength=0.1):
audio_spec, audio_angles = self.stft.transform(audio.cuda().float())
audio_spec_denoised = audio_spec - self.bias_spec * strength
audio_spec_denoised = torch.clamp(audio_spec_denoised, 0.0)
audio_denoised = self.stft.inverse(audio_spec_denoised, audio_angles)
return audio_denoised
if __name__ == '__main__':
config = HParams()
checkpoint = 'tacotron2-cn.pt'
print('loading model: {}...'.format(checkpoint))
model = Tacotron2(config)
model.load_state_dict(torch.load(checkpoint))
model = model.to('cpu')
model.eval()
waveglow_path = 'waveglow_256channels.pt'
waveglow = torch.load(waveglow_path)['model']
waveglow.cuda().eval().half()
for k in waveglow.convinv:
k.float()
denoiser = Denoiser(waveglow)
text = "相对论直接和间接的催生了量子力学的诞生 也为研究微观世界的高速运动确立了全新的数学模型"
text = pinyin.get(text, format="numerical", delimiter=" ")
print(text)
sequence = np.array(text_to_sequence(text))[None, :]
import time
import numpy as np
import torch
from tqdm import tqdm
import config
from models.models import Tacotron2
from utils import text_to_sequence, HParams
if __name__ == '__main__':
checkpoint = 'tacotron2-cn.pt'
print('loading model: {}...'.format(checkpoint))
model = Tacotron2(HParams())
model.load_state_dict(torch.load(checkpoint))
model = model.to('cpu')
model.eval()
filename = config.validation_files
with open(filename, 'r') as file:
lines = file.readlines()
num_samples = len(lines)
print('num_samples: ' + str(num_samples))
elapsed = 0
# Batches
for line in tqdm(lines):
tokens = line.strip().split('|')
text = tokens[1]
sequence = np.array(text_to_sequence(text))[None, :]