def main():
json_path = os.path.join(args.model_dir)
params = utils.Params(json_path)
net = Unet(params.model).cuda()
# TODO - check exists
#checkpoint = torch.load('./final.pth.tar')
#net.load_state_dict(checkpoint)
train_dataset = AudioDataset(data_type='train')
test_dataset = AudioDataset(data_type='val')
train_data_loader = DataLoader(dataset=train_dataset,
batch_size=args.batch_size,
collate_fn=train_dataset.collate,
shuffle=True,
num_workers=4)
test_data_loader = DataLoader(dataset=test_dataset,
batch_size=args.batch_size,
collate_fn=test_dataset.collate,
shuffle=False,
num_workers=4)
torch.set_printoptions(precision=10, profile="full")
# Optimizer
optimizer = optim.Adam(net.parameters(), lr=1e-3)
# Learning rate scheduler
scheduler = ExponentialLR(optimizer, 0.95)
for epoch in range(args.num_epochs):
train_bar = tqdm(train_data_loader)
for input in train_bar:
train_mixed, train_clean, seq_len = map(lambda x: x.cuda(), input)
mixed = stft(train_mixed).unsqueeze(dim=1)
real, imag = mixed[..., 0], mixed[..., 1]
out_real, out_imag = net(real, imag)
out_real, out_imag = torch.squeeze(out_real,
1), torch.squeeze(out_imag, 1)
out_audio = istft(out_real, out_imag, train_mixed.size(1))
out_audio = torch.squeeze(out_audio, dim=1)
for i, l in enumerate(seq_len):
out_audio[i, l:] = 0
librosa.output.write_wav(
'mixed.wav', train_mixed[0].cpu().data.numpy()
[:seq_len[0].cpu().data.numpy()], 16000)
librosa.output.write_wav(
'clean.wav', train_clean[0].cpu().data.numpy()
[:seq_len[0].cpu().data.numpy()], 16000)
librosa.output.write_wav(
'out.wav', out_audio[0].cpu().data.numpy()
[:seq_len[0].cpu().data.numpy()], 16000)
loss = wSDRLoss(train_mixed, train_clean, out_audio)
print(epoch, loss)
optimizer.zero_grad()
loss.backward()
optimizer.step()
scheduler.step()
torch.save(net.state_dict(), './final.pth.tar')
def main():
json_path = os.path.join(args.conf)
params = utils.Params(json_path)
net = Unet(params.model).cuda()
# TODO - check exists
# if os.path.exists('./ckpt/final.pth.tar'):
# checkpoint = torch.load('./ckpt/final.pth.tar')
# net.load_state_dict(checkpoint)
train_dataset = AudioDataset(data_type='train')
# test_dataset = AudioDataset(data_type='val')
train_data_loader = DataLoader(dataset=train_dataset, batch_size=args.batch_size,
collate_fn=train_dataset.collate, shuffle=True, num_workers=0)
# test_data_loader = DataLoader(dataset=test_dataset, batch_size=args.batch_size,
# collate_fn=test_dataset.collate, shuffle=False, num_workers=4)
# torch.set_printoptions(precision=10, profile="full")
# Optimizer
optimizer = optim.Adam(net.parameters(), lr=1e-2)
# Learning rate scheduler
scheduler = ExponentialLR(optimizer, 0.996)
if not os.path.exists('ckpt'): # model save dir
os.mkdir('ckpt')
for epoch in range(1, args.num_epochs+1):
train_bar = tqdm(train_data_loader, ncols=60)
loss_sum = 0.0
step_cnt = 0
for input_ in train_bar:
train_mixed, train_clean, seq_len = map(lambda x: x.cuda(), input_)
mixed = stft(train_mixed).unsqueeze(dim=1)
real, imag = mixed[..., 0], mixed[..., 1]
out_real, out_imag = net(real, imag)
out_real, out_imag = torch.squeeze(out_real, 1), torch.squeeze(out_imag, 1)
out_audio = istft(out_real, out_imag, train_mixed.size(1))
out_audio = torch.squeeze(out_audio, dim=1)
for i, l in enumerate(seq_len):
out_audio[i, l:] = 0
# librosa.output.write_wav('mixed.wav', train_mixed[0].cpu().data.numpy()[:seq_len[0].cpu().data.numpy()], 16000)
# librosa.output.write_wav('clean.wav', train_clean[0].cpu().data.numpy()[:seq_len[0].cpu().data.numpy()], 16000)
# librosa.output.write_wav('out.wav', out_audio[0].cpu().data.numpy()[:seq_len[0].cpu().data.numpy()], 16000)
loss = wSDRLoss(train_mixed, train_clean, out_audio)
# print(epoch, loss.item(), end='', flush=True)
loss_sum += loss.item()
step_cnt += 1
optimizer.zero_grad()
loss.backward()
optimizer.step()
avg_loss = loss_sum / step_cnt
print('epoch %d> Avg_loss: %.6f.\n' % (epoch, avg_loss))
scheduler.step()
if epoch %20 == 0:
torch.save(net.state_dict(), './ckpt/step%05d.pth.tar' % epoch)
def unet_tf_pth(checkpoint_path, pth_output_path):
model = Unet().eval()
state_dict = model.state_dict()
reader = tf.train.NewCheckpointReader(checkpoint_path)
pth_keys = state_dict.keys()
keys = sorted(reader.get_variable_to_shape_map().keys())
print(keys)
print(pth_keys)
# training of resnet
rdf_inputs1 = rdf_inputs.to(device1, dtype=torch.float)
inputs_cat = torch.cat((rdf_inputs1, qsm_inputs1), dim=1)
rdfs1 = rdfs.to(device1, dtype=torch.float)
masks1 = masks.to(device1, dtype=torch.float)
weights1 = weights.to(device1, dtype=torch.float)
wGs1 = wGs.to(device1, dtype=torch.float)
loss_fidelity = BayesianQSM_train(model=resnet,
input_RDFs=inputs_cat,
in_loss_RDFs=rdfs1,
QSMs=0,
Masks=masks1,
fidelity_Ws=weights1,
gradient_Ws=wGs1,
D=np.asarray(D[0, ...]),
flag_COSMOS=0,
optimizer=optimizer1,
sigma_sq=0,
Lambda_tv=0,
voxel_size=(1, 1, 3),
K=1,
flag_l1=2)
print('epochs: [%d/%d], time: %ds, Fidelity loss of resnet: %f' %
(epoch, niter, time.time() - t0, loss_fidelity))
print(' ')
torch.save(unet3d.state_dict(), rootDir + '/unet3d_fine.pt')
torch.save(resnet.state_dict(), rootDir + '/resnet_fine.pt')
l2_regularisation(net.prior)
loss = -elbo + 1e-5 * reg_loss
klEpoch.append(kl.item())
recEpoch.append(recLoss.item())
else:
pred = torch.sigmoid(net.forward(patch, False))
loss = criterion(target=mask, input=pred)
vlLoss.append(loss.item())
break
print ('Epoch [{}/{}], Step [{}/{}], TrLoss: {:.4f}, VlLoss: {:.4f}, RecLoss: {:.4f}, kl: {:.4f}, GED: {:.4f}'
.format(epoch+1, args.epochs, step+1, nTrain, trLoss[-1], vlLoss[-1], recLoss.item(),\
kl.item(), vlGed[-1]))
epValidLoss = np.mean(vlLoss)
if (epoch + 1) % 1 == 0 and epValidLoss > 0 and epValidLoss < minLoss:
convIter = 0
minLoss = epValidLoss
print("New min: %.2f\nSaving model..." % (minLoss))
torch.save(net.state_dict(), '../models/' + fName + '.pt')
else:
convIter += 1
writeLog(logFile, epoch, np.mean(trLoss), epValidLoss, np.mean(recEpoch),
np.mean(klEpoch),
time.time() - t)
if convIter == convCheck:
print("Converged at epoch %d" % (epoch + 1 - convCheck))
break
elif np.isnan(epValidLoss):
print("Nan error!")
break
for idx, (rdfs, masks, qsms) in enumerate(valLoader):
idx += 1
rdfs = (rdfs.to(device, dtype=torch.float) + trans) * scale
qsms = (qsms.to(device, dtype=torch.float) + trans) * scale
masks = masks.to(device, dtype=torch.float)
outputs1 = unet3d(rdfs)
outputs2 = resnet(torch.cat((rdfs, outputs1), 1))
loss1 = loss_QSMnet(outputs1, qsms, masks, D)
loss2 = loss_QSMnet(outputs2, qsms, masks, D)
loss = loss1 + loss2
loss_total += loss
print('\n Validation loss: %f \n' % (loss_total / idx))
Validation_loss.append(loss_total / idx)
logger.print_and_save('Epoch: [%d/%d], Loss in Validation: %f' %
(epoch, niter, Validation_loss[-1]))
if Validation_loss[-1] == min(Validation_loss):
torch.save(
unet3d.state_dict(), rootDir +
'/linear_factor={0}_validation={1}_test={2}_unet3d'.format(
opt['linear_factor'], opt['case_validation'],
opt['case_test']) + '.pt')
torch.save(
resnet.state_dict(), rootDir +
'/linear_factor={0}_validation={1}_test={2}_resnet'.format(
opt['linear_factor'], opt['case_validation'],
opt['case_test']) + '.pt')
for idx, (rdfs, masks, weights, qsms) in enumerate(valLoader):
idx += 1
rdfs = (rdfs.to(device, dtype=torch.float) + trans) * scale
qsms = (qsms.to(device, dtype=torch.float) + trans) * scale
masks = masks.to(device, dtype=torch.float)
outputs = unet3d(rdfs)
mean_Maps = outputs[:, 0:1, ...]
var_Maps = outputs[:, 1:2, ...]
# loss1 = 1/2*torch.sum((mean_Maps - qsms)**2 / torch.exp(var_Maps))
# loss2 = 1/2*torch.sum(var_Maps)
loss1 = 1 / 2 * torch.sum(
(mean_Maps * masks - qsms * masks)**2 / var_Maps)
loss2 = 1 / 2 * torch.sum(torch.log(var_Maps) * masks)
loss = loss1 + loss2
loss_total += loss.item()
print('\n Validation loss: %f \n' % (loss_total / idx))
Validation_loss.append(loss_total / idx)
logger.print_and_save('Epoch: [%d/%d], loss in Validation: %f' %
(epoch, niter, Validation_loss[-1]))
if Validation_loss[-1] == min(Validation_loss):
torch.save(
unet3d.state_dict(),
rootDir + '/weights_rsa={0}_validation={1}_test={2}'.format(
opt['flag_rsa'], opt['case_validation'],
opt['case_test']) + '.pt')
# flag_COSMOS=flag_COSMOS,
# optimizer=optimizer,
# sigma_sq=sigma_sq,
# Lambda_tv=Lambda_tv,
# voxel_size=voxel_size
# )
errl1 = BayesianQSM_train(
unet3d=unet3d,
input_RDFs=input_RDFs,
in_loss_RDFs=in_loss_RDFs,
QSMs=QSMs,
Masks=Masks,
fidelity_Ws=fidelity_Ws,
gradient_Ws=gradient_Ws,
D=D,
flag_COSMOS=flag_COSMOS,
optimizer=optimizer,
sigma_sq=sigma_sq,
Lambda_tv=Lambda_tv,
voxel_size=voxel_size
)
print(errl1)
print('\n')
print('Finish current epoch')
torch.save(unet3d.state_dict(), rootDir+'/weights.pt')
else:
outputs = unet3d(rdfs_input)
mean_Maps = outputs[:, 0:1, ...]
var_Maps = outputs[:, 1:2, ...]
loss1 = 1 / 2 * torch.sum(
(mean_Maps * masks - qsms * masks)**2 / var_Maps)
loss2 = 1 / 2 * torch.sum(torch.log(var_Maps) * masks)
loss = loss1 + loss2
loss_total += loss.item()
val_loss.append(loss_total)
if val_loss[-1] == min(val_loss):
if flag_VI:
torch.save(
unet3d.state_dict(), rootDir + folder_weights +
'/weights_PDI_VI0.pt'.format(Lambda_tv))
else:
torch.save(unet3d.state_dict(),
rootDir + folder_weights + '/weights_PDI.pt')
# test phase
else:
# dataloader
dataLoader_test = Simulation_ICH_loader(split='test')
testLoader = data.DataLoader(dataLoader_test,
batch_size=batch_size,
shuffle=True)
if flag_VI:
# unet3d.load_state_dict(torch.load(rootDir+folder_weights+'/weights_PDI_VI0.pt')) # used for mean prediction
wGs = wGs.to(device, dtype=torch.float)
# calculate KLD
outputs = unet3d(rdfs)
loss_kl = loss_KL(outputs=outputs,
QSMs=0,
flag_COSMOS=0,
sigma_sq=0)
loss_expectation, loss_tv = loss_Expectation(
outputs=outputs,
QSMs=0,
in_loss_RDFs=rdfs - trans * scale,
fidelity_Ws=weights,
gradient_Ws=wGs,
D=np.asarray(D[0, ...]),
flag_COSMOS=0,
Lambda_tv=Lambda_tv,
voxel_size=voxel_size,
K=K)
loss_total += (loss_kl + loss_expectation + loss_tv).item()
print('KL Divergence on validation set = {0}'.format(loss_total))
val_loss.append(loss_total)
if val_loss[-1] == min(val_loss):
if Lambda_tv:
torch.save(
unet3d.state_dict(), rootDir + folder_weights_VI +
'/weights_vi_cosmos_{}_9.pt'.format(Lambda_tv))
torch.save(
unet3d.state_dict(), rootDir + folder_weights_VI +
'/weights_vi_cosmos_{}_last_9.pt'.format(Lambda_tv))
def train(args):
# Setup Dataloader
data_json = json.load(open('config.json'))
data_path=data_json[args.dataset]['data_path']
t_loader = SaltLoader(data_path, img_size_ori=args.img_size_ori,img_size_target=args.img_size_target)
v_loader = SaltLoader(data_path, split='val',img_size_ori=args.img_size_ori, img_size_target=args.img_size_target)
train_loader = data.DataLoader(t_loader, batch_size=args.batch_size, num_workers=8, shuffle=True)
val_loader = data.DataLoader(v_loader, batch_size=args.batch_size, num_workers=8)
# Setup Model
if args.arch=='unet':
model = Unet(start_fm=16)
else:
model=Unet_upsample(start_fm=16)
print(model)
total = sum([param.nelement() for param in model.parameters()])
print('Number of params: %.2fM' % (total / 1e6))
model.cuda()
# Check if model has custom optimizer / loss
optimizer = torch.optim.Adam(model.parameters(), lr=args.l_rate)
loss_fn= nn.BCEWithLogitsLoss()
best_loss=100
mean_train_losses = []
mean_val_losses = []
for epoch in range(args.n_epoch):
train_losses = []
val_losses = []
for images, masks in train_loader:
images = Variable(images.cuda())
masks = Variable(masks.cuda())
outputs = model(images)
loss = loss_fn(outputs, masks)
train_losses.append(loss.data)
optimizer.zero_grad()
loss.backward()
optimizer.step()
for images, masks in val_loader:
images = Variable(images.cuda())
masks = Variable(masks.cuda())
outputs = model(images)
loss = loss_fn(outputs, masks)
val_losses.append(loss.data)
mean_train_losses.append(np.mean(train_losses))
mean_val_losses.append(np.mean(val_losses))
if np.mean(val_losses) < best_loss:
best_loss = np.mean(val_losses)
state = {'epoch': epoch + 1,
'model_state': model.state_dict(),
'optimizer_state': optimizer.state_dict(), }
torch.save(state, "./saved_models/{}_{}_best_model.pkl".format(args.arch, args.dataset))
# Print Loss
print('Epoch: {}. Train Loss: {}. Val Loss: {}'.format(epoch + 1, np.mean(train_losses), np.mean(val_losses)))
state = {'model_state': model.state_dict(),
'optimizer_state': optimizer.state_dict(), }
torch.save(state, "./saved_models/{}_{}_final_model.pkl".format(args.arch, args.dataset))
print("saved two models in ./saved_models")
for idx, (ifreqs, masks, data_weights,
wGs) in enumerate(valLoader):
ifreqs = ifreqs.to(device, dtype=torch.float)
masks = masks.to(device, dtype=torch.float)
data_weights = data_weights.to(device, dtype=torch.float)
wGs = wGs.to(device, dtype=torch.float)
loss_PDF, loss_fidelity, loss_tv = utfi_train(model,
optimizer,
ifreqs,
masks,
data_weights,
wGs,
D,
D_smv,
lambda_pdf,
lambda_tv,
voxel_size,
flag_train=0)
loss_total = loss_PDF + loss_fidelity + loss_tv
loss_total_list.append(np.asarray(loss_total))
Validation_loss.append(
sum(loss_total_list) / float(len(loss_total_list)))
if Validation_loss[-1] == min(Validation_loss):
torch.save(
model.state_dict(),
rootDir + '/weights/weight_pdf={0}_tv={1}.pt'.format(
lambda_pdf, lambda_tv))
epoch += 1
