def test(epoch, loader):
model.eval()
decoder_class_losses = LossDict([decoder_class], "acoustic_model")
batches_processed = 0
for batch_idx, (all_feats, all_targets, phones) in enumerate(loader):
# Get data for the decoder class
# Set to volatile so history isn't saved (i.e., not training time)
feats = all_feats[0]
targets = all_targets[0]
if on_gpu:
feats = feats.cuda()
targets = targets.cuda()
feats = Variable(feats, volatile=True)
targets = Variable(targets, volatile=True)
# Set up phones
if on_gpu:
phones = phones.cuda()
phones = Variable(phones, volatile=True)
# Phone classifier testing
# Forward pass through phone classifier
log_probs = model.classify(feats)
# Compute class loss and backward pass
c_loss = class_loss(log_probs, phones)
decoder_class_losses.add(decoder_class,
{"phones_xent": c_loss.data[0]})
batches_processed += 1
return decoder_class_losses
def train(epoch):
model.train()
# Set up some bookkeeping on loss values
decoder_class_losses = LossDict(decoder_classes, "end2end_phone_net")
batches_processed = 0
for batch_idx, (all_feats, all_targets, phones) in enumerate(train_loader):
# Get data for each decoder class
feat_dict = dict()
targets_dict = dict()
for i in range(len(all_feats)):
decoder_class = decoder_classes[i]
feats = all_feats[i]
targets = all_targets[i]
if on_gpu:
feats = feats.cuda()
targets = targets.cuda()
feats = Variable(feats)
targets = Variable(targets)
feat_dict[decoder_class] = feats
targets_dict[decoder_class] = targets
# Set up phones
if on_gpu:
phones = phones.cuda()
phones = Variable(phones)
# Phone classifier training
optimizer.zero_grad()
total_loss = 0.0
feats = feat_dict["clean"]
# Forward pass through phone classifier
log_probs = model.classify(feats)
# Compute class loss and backward pass
c_loss = class_loss(log_probs, phones)
total_loss += c_loss
decoder_class_losses.add("clean", {"phones_xent": c_loss.data[0]})
# Update generator
total_loss.backward()
optimizer.step()
# Print updates, if any
batches_processed += 1
if batches_processed % log_interval == 0:
print("Train epoch %d: [%d/%d (%.1f%%)]" %
(epoch, batches_processed, len(train_loader),
batches_processed / len(train_loader) * 100.0),
flush=True)
print(decoder_class_losses, flush=True)
return decoder_class_losses
def test(epoch, loader):
model.eval()
decoder_class_losses = LossDict(decoder_classes, "multitask_net")
batches_processed = 0
for batch_idx, (all_feats, all_targets, phones) in enumerate(loader):
# Get data for each decoder class
feat_dict = dict()
targets_dict = dict()
for i in range(len(all_feats)):
decoder_class = decoder_classes[i]
# Set to volatile so history isn't saved (i.e., not training time)
feats = all_feats[i]
targets = all_targets[i]
if on_gpu:
feats = feats.cuda()
targets = targets.cuda()
feats = Variable(feats, volatile=True)
targets = Variable(targets, volatile=True)
feat_dict[decoder_class] = feats
targets_dict[decoder_class] = targets
# Set up phones
if on_gpu:
phones = phones.cuda()
phones = Variable(phones, volatile=True)
# Test enhancement
for source_class in decoder_classes:
feats = feat_dict[source_class]
targets = targets_dict["clean"]
# Forward pass through just enhancement net
enhanced_feats = model.enhance(feats)
# Compute reconstruction loss
r_loss = reconstruction_loss(enhanced_feats, targets)
if source_class == "clean":
decoder_class_losses.add(
source_class, {"reconstruction_loss": r_loss.data[0]})
else:
decoder_class_losses.add(source_class,
{"enhancement_loss": r_loss.data[0]})
# Test phone classifier (clean data only)
# Forward pass enhanced feats through phone classifier
feats = feat_dict["clean"]
log_probs = model.classify(feats)
# Compute class loss
c_loss = class_loss(log_probs, phones)
decoder_class_losses.add("clean", {"phones_xent": c_loss.data[0]})
batches_processed += 1
return decoder_class_losses
def train(epoch):
model.train()
# Set up some bookkeeping on loss values
decoder_class_losses = LossDict([decoder_class], "acoustic_model")
batches_processed = 0
for batch_idx, (all_feats, all_targets, phones) in enumerate(train_loader):
# Get data for the decoder class
feats = all_feats[0]
targets = all_targets[0]
if on_gpu:
feats = feats.cuda()
targets = targets.cuda()
feats = Variable(feats)
targets = Variable(targets)
# Set up phones
if on_gpu:
phones = phones.cuda()
phones = Variable(phones)
# Phone classifier training
optimizer.zero_grad()
# Forward pass through phone classifier
log_probs = model.classify(feats)
# Compute class loss and backward pass
c_loss = class_loss(log_probs, phones)
decoder_class_losses.add(decoder_class,
{"phones_xent": c_loss.data[0]})
# Update generator
c_loss.backward()
optimizer.step()
# Print updates, if any
batches_processed += 1
if batches_processed % log_interval == 0:
print("Train epoch %d: [%d/%d (%.1f%%)]" %
(epoch, batches_processed, len(train_loader),
batches_processed / len(train_loader) * 100.0),
flush=True)
print(decoder_class_losses, flush=True)
return decoder_class_losses
def test(epoch, loader):
model.eval()
decoder_class_losses = LossDict(decoder_classes, "end2end_phone_net")
batches_processed = 0
for batch_idx, (all_feats, all_targets, phones) in enumerate(loader):
# Get data for each decoder class
feat_dict = dict()
targets_dict = dict()
for i in range(len(all_feats)):
decoder_class = decoder_classes[i]
# Set to volatile so history isn't saved (i.e., not training time)
feats = all_feats[i]
targets = all_targets[i]
if on_gpu:
feats = feats.cuda()
targets = targets.cuda()
feats = Variable(feats, volatile=True)
targets = Variable(targets, volatile=True)
feat_dict[decoder_class] = feats
targets_dict[decoder_class] = targets
# Set up phones
if on_gpu:
phones = phones.cuda()
phones = Variable(phones, volatile=True)
# Phone classifier testing
feats = feat_dict["clean"]
# Forward pass through phone classifier
log_probs = model.classify(feats)
# Compute class loss
c_loss = class_loss(log_probs, phones)
decoder_class_losses.add("clean", {"phones_xent": c_loss.data[0]})
batches_processed += 1
return decoder_class_losses
def test(loader):
model.eval()
decoder_class_losses = LossDict(decoder_classes, "multitask_md")
batches_processed = 0
for batch_idx, (all_feats, all_targets, phones) in enumerate(loader):
# Get data for each decoder class
feat_dict = dict()
targets_dict = dict()
for i in range(len(all_feats)):
decoder_class = decoder_classes[i]
# Set to volatile so history isn't saved (i.e., not training time)
feats = all_feats[i]
targets = all_targets[i]
if on_gpu:
feats = feats.cuda()
targets = targets.cuda()
feats = Variable(feats, volatile=True)
targets = Variable(targets, volatile=True)
feat_dict[decoder_class] = feats
targets_dict[decoder_class] = targets
# Set up phones
if on_gpu:
phones = phones.cuda()
phones = Variable(phones, volatile=True)
# Test reconstruction/transformation
for source_class in decoder_classes:
for target_class in decoder_classes:
feats = feat_dict[source_class]
targets = targets_dict[target_class]
recon_x = model.forward_decoder(feats, target_class)
r_loss = reconstruction_loss(recon_x, targets)
if target_class == source_class:
decoder_class_losses.add(source_class, {"reconstruction_loss": r_loss.data[0]})
else:
decoder_class_losses.add(source_class, {"transformation_loss": r_loss.data[0]})
# Test phone classifier on clean data
feats = feat_dict["clean"]
log_probs = model.classify(feats)
c_loss = class_loss(log_probs, phones)
decoder_class_losses.add("clean", {"phones_xent": c_loss.data[0]})
batches_processed += 1
return decoder_class_losses
def train(epoch):
model.train()
# Set up some bookkeeping on loss values
decoder_class_losses = LossDict(decoder_classes, "enhancement_net")
batches_processed = 0
for batch_idx, (all_feats, all_targets) in enumerate(train_loader):
# Get data for each decoder class
feat_dict = dict()
targets_dict = dict()
for i in range(len(all_feats)):
decoder_class = decoder_classes[i]
feats = all_feats[i]
targets = all_targets[i]
if on_gpu:
feats = feats.cuda()
targets = targets.cuda()
feats = Variable(feats)
targets = Variable(targets)
feat_dict[decoder_class] = feats
targets_dict[decoder_class] = targets
optimizer.zero_grad()
total_loss = 0.0
# Step 1: reconstruction/clean->clean
feats = feat_dict["clean"]
targets = targets_dict["clean"]
recon_x = model.forward(feats)
r_loss = reconstruction_loss(recon_x, targets)
total_loss += r_loss
decoder_class_losses.add("clean",
{"reconstruction_loss": r_loss.data[0]})
# Step 2: enhancement/dirty->clean
feats = feat_dict["dirty"]
targets = targets_dict["clean"]
recon_x = model.forward(feats)
r_loss = reconstruction_loss(recon_x, targets)
total_loss += r_loss
decoder_class_losses.add("dirty", {"enhancement_loss": r_loss.data[0]})
# Update generator
total_loss.backward()
optimizer.step()
# Print updates, if any
batches_processed += 1
if batches_processed % log_interval == 0:
print("Train epoch %d: [%d/%d (%.1f%%)]" %
(epoch, batches_processed, len(train_loader),
batches_processed / len(train_loader) * 100.0),
flush=True)
print(decoder_class_losses, flush=True)
return decoder_class_losses
def test(epoch, loader):
model.eval()
decoder_class_losses = LossDict(decoder_classes, denoiser=True)
batches_processed = 0
for batch_idx, (all_feats, all_targets) in enumerate(loader):
# Get data for each decoder class
feat_dict = dict()
targets_dict = dict()
for i in range(len(all_feats)):
decoder_class = decoder_classes[i]
# Set to volatile so history isn't saved (i.e., not training time)
feats = all_feats[i]
targets = all_targets[i]
if on_gpu:
feats = feats.cuda()
targets = targets.cuda()
feats = Variable(feats, volatile=True)
targets = Variable(targets, volatile=True)
feat_dict[decoder_class] = feats
targets_dict[decoder_class] = targets
# STEP 1: Autoencoder testing
if use_reconstruction:
# PHASE 1: Backprop clean data through clean decoder (reconstruction)
feats = feat_dict["clean"]
targets = targets_dict["clean"]
# Run features through same decoder
recon_batch = model.forward_decoder(feats, "clean")
r_loss = reconstruction_loss(recon_batch, targets)
decoder_class_losses.add(
"clean", {"autoencoding_recon_loss": r_loss.data[0]})
if use_transformation:
# PHASE 2: Backprop dirty data through clean decoder (denoising/transformation)
feats = feat_dict["dirty"]
targets_other = targets_dict["clean"]
# Run features through other decoder
translated_feats = model.forward_decoder(feats, "clean")
r_loss = reconstruction_loss(translated_feats, targets_other)
decoder_class_losses.add(
"dirty", {"transformation_recon_loss": r_loss.data[0]})
batches_processed += 1
return decoder_class_losses
def test(loader):
model.eval()
decoder_class_losses = LossDict(decoder_classes, "enhancement_net")
batches_processed = 0
for batch_idx, (all_feats, all_targets) in enumerate(loader):
# Get data for each decoder class
feat_dict = dict()
targets_dict = dict()
for i in range(len(all_feats)):
decoder_class = decoder_classes[i]
# Set to volatile so history isn't saved (i.e., not training time)
feats = all_feats[i]
targets = all_targets[i]
if on_gpu:
feats = feats.cuda()
targets = targets.cuda()
feats = Variable(feats, volatile=True)
targets = Variable(targets, volatile=True)
feat_dict[decoder_class] = feats
targets_dict[decoder_class] = targets
# Step 1: reconstruction/clean->clean
feats = feat_dict["clean"]
targets = targets_dict["clean"]
recon_x = model.forward(feats)
r_loss = reconstruction_loss(recon_x, targets)
decoder_class_losses.add("clean",
{"reconstruction_loss": r_loss.data[0]})
# Step 2: enhancement/dirty->clean
feats = feat_dict["dirty"]
targets = targets_dict["clean"]
recon_x = model.forward(feats)
r_loss = reconstruction_loss(recon_x, targets)
decoder_class_losses.add("dirty", {"enhancement_loss": r_loss.data[0]})
batches_processed += 1
return decoder_class_losses
def test(loader):
model.eval()
decoder_class_losses = LossDict(decoder_classes, "enhancement_md")
batches_processed = 0
for batch_idx, (all_feats, all_targets) in enumerate(loader):
# Get data for each decoder class
feat_dict = dict()
targets_dict = dict()
for i in range(len(all_feats)):
decoder_class = decoder_classes[i]
# Set to volatile so history isn't saved (i.e., not training time)
feats = all_feats[i]
targets = all_targets[i]
if on_gpu:
feats = feats.cuda()
targets = targets.cuda()
feats = Variable(feats, volatile=True)
targets = Variable(targets, volatile=True)
feat_dict[decoder_class] = feats
targets_dict[decoder_class] = targets
for source_class in decoder_classes:
for target_class in decoder_classes:
feats = feat_dict[source_class]
targets = targets_dict[target_class]
recon_x = model.forward_decoder(feats, target_class)
r_loss = reconstruction_loss(recon_x, targets)
if target_class == source_class:
decoder_class_losses.add(
source_class, {"reconstruction_loss": r_loss.data[0]})
else:
decoder_class_losses.add(
source_class, {"transformation_loss": r_loss.data[0]})
batches_processed += 1
return decoder_class_losses
def train(epoch):
model.train()
# Set up some bookkeeping on loss values
decoder_class_losses = LossDict(decoder_classes, "multitask_net")
batches_processed = 0
for batch_idx, (all_feats, all_targets, phones) in enumerate(train_loader):
# Get data for each decoder class
feat_dict = dict()
targets_dict = dict()
for i in range(len(all_feats)):
decoder_class = decoder_classes[i]
feats = all_feats[i]
targets = all_targets[i]
if on_gpu:
feats = feats.cuda()
targets = targets.cuda()
feats = Variable(feats)
targets = Variable(targets)
feat_dict[decoder_class] = feats
targets_dict[decoder_class] = targets
# Set up phones
if on_gpu:
phones = phones.cuda()
phones = Variable(phones)
# Step 1: Phone classifier training (for clean data only)
optimizer.zero_grad()
feats = feat_dict["clean"]
# Forward pass through classifier
log_probs = model.classify(feats)
# Compute class loss
c_loss = class_loss(log_probs, phones)
decoder_class_losses.add("clean", {"phones_xent": c_loss.data[0]})
c_loss.backward()
optimizer.step()
# Step 2: Enhancement net training
optimizer.zero_grad()
total_loss = 0.0
for source_class in decoder_classes:
feats = feat_dict[source_class]
targets = targets_dict["clean"]
# Forward pass through just enhancement net
enhanced_feats = model.enhance(feats)
# Compute reconstruction loss
r_loss = reconstruction_loss(enhanced_feats, targets)
total_loss += r_loss
if source_class == "clean":
decoder_class_losses.add(
source_class, {"reconstruction_loss": r_loss.data[0]})
else:
decoder_class_losses.add(source_class,
{"enhancement_loss": r_loss.data[0]})
total_loss.backward()
optimizer.step()
# Print updates, if any
batches_processed += 1
if batches_processed % log_interval == 0:
print("Train epoch %d: [%d/%d (%.1f%%)]" %
(epoch, batches_processed, len(train_loader),
batches_processed / len(train_loader) * 100.0),
flush=True)
print(decoder_class_losses, flush=True)
return decoder_class_losses
def train(epoch):
model.train()
# Set up some bookkeeping on loss values
decoder_class_losses = LossDict(decoder_classes, e2e=True)
batches_processed = 0
for batch_idx, (all_feats, all_targets, phones) in enumerate(train_loader):
# Get data for each decoder class
feat_dict = dict()
targets_dict = dict()
for i in range(len(all_feats)):
decoder_class = decoder_classes[i]
feats = all_feats[i]
targets = all_targets[i]
if on_gpu:
feats = feats.cuda()
targets = targets.cuda()
feats = Variable(feats)
targets = Variable(targets)
feat_dict[decoder_class] = feats
targets_dict[decoder_class] = targets
# Set up phones
if on_gpu:
phones = phones.cuda()
phones = Variable(phones)
# Use one loss that is a sum of enhancement and phone losses,
# so that the total loss is backprop'ed all at once
total_loss = 0.0
generator_optimizer.zero_grad()
# STEP 1: Enhancement losses
if use_reconstruction:
# PHASE 1: Backprop clean data through same decoder (reconstruction)
feats = feat_dict["clean"]
targets = targets_dict["clean"]
# Forward pass through same decoder
recon_batch = model.forward_decoder(feats, "clean")
# Compute reconstruction loss and backward pass
r_loss = reconstruction_loss(recon_batch, targets)
total_loss += r_loss
decoder_class_losses.add(
"clean", {"autoencoding_recon_loss": r_loss.data[0]})
if use_transformation:
# PHASE 2: Backprop dirty data through clean decoder (denoising/transformation)
feats = feat_dict["dirty"]
targets_other = targets_dict["clean"]
# Forward pass through other decoder
transformed_feats = model.forward_decoder(feats, "clean")
# Compute reconstruction loss and backward pass
r_loss = reconstruction_loss(transformed_feats, targets_other)
total_loss += r_loss
decoder_class_losses.add(
"dirty", {"transformation_recon_loss": r_loss.data[0]})
# STEP 2: Phone classifier training
for source_class in decoder_classes:
feats = feat_dict[source_class]
# Forward pass through phone classifier
log_probs = model.forward_phones(feats)
# Compute class loss and backward pass
c_loss = class_loss(log_probs, phones)
total_loss += c_loss
decoder_class_losses.add(source_class,
{"phone_loss": c_loss.data[0]})
# Update generator
total_loss.backward()
generator_optimizer.step()
# Print updates, if any
batches_processed += 1
if batches_processed % log_interval == 0:
print("Train epoch %d: [%d/%d (%.1f%%)]" %
(epoch, batches_processed, len(train_loader),
batches_processed / len(train_loader) * 100.0),
flush=True)
print(decoder_class_losses, flush=True)
return decoder_class_losses
def train(epoch):
model.train()
# Set up some bookkeeping on loss values
decoder_class_losses = LossDict(decoder_classes, denoiser=True)
batches_processed = 0
for batch_idx, (all_feats, all_targets) in enumerate(training_loader):
# Get data for each decoder class
feat_dict = dict()
targets_dict = dict()
for i in range(len(all_feats)):
decoder_class = decoder_classes[i]
feats = all_feats[i]
targets = all_targets[i]
if on_gpu:
feats = feats.cuda()
targets = targets.cuda()
feats = Variable(feats)
targets = Variable(targets)
feat_dict[decoder_class] = feats
targets_dict[decoder_class] = targets
# STEP 1: Generator training
if use_reconstruction:
# PHASE 1: Backprop clean data through same decoder (reconstruction)
generator_optimizer.zero_grad()
feats = feat_dict["clean"]
targets = targets_dict["clean"]
# Forward pass through same decoder
recon_batch = model.forward_decoder(feats, "clean")
# Compute reconstruction loss and backward pass
r_loss = reconstruction_loss(recon_batch, targets)
r_loss.backward()
decoder_class_losses.add(
"clean", {"autoencoding_recon_loss": r_loss.data[0]})
# Update generator
generator_optimizer.step()
if use_transformation:
# PHASE 2: Backprop dirty data through clean decoder (denoising/transformation)
generator_optimizer.zero_grad()
feats = feat_dict["dirty"]
targets_other = targets_dict["clean"]
# Forward pass through other decoder
transformed_feats = model.forward_decoder(feats, "clean")
# Compute reconstruction loss and backward pass
r_loss = reconstruction_loss(transformed_feats, targets_other)
r_loss.backward()
decoder_class_losses.add(
"dirty", {"transformation_recon_loss": r_loss.data[0]})
# Update generator
generator_optimizer.step()
# Print updates, if any
batches_processed += 1
if batches_processed % log_interval == 0:
print("Train epoch %d: [%d/%d (%.1f%%)]" %
(epoch, batches_processed, len(training_loader),
batches_processed / len(training_loader) * 100.0),
flush=True)
print(decoder_class_losses, flush=True)
return decoder_class_losses
