def main(opt):
if opt.useAE == 1:
useAE = True
else:
useAE = False
if opt.seed != -1:
random.seed(opt.seed)
ctx = mx.gpu() if opt.use_gpu else mx.cpu()
inclasspaths , inclasses = dload.loadPaths(opt.dataset, opt.datapath, opt.expname, opt.batch_size+1, opt.classes)
train_data, val_data = load_image.load_image(inclasspaths, opt.batch_size, opt.img_wd, opt.img_ht, opt.noisevar)
print('Data loading done.')
if opt.istest:
print('testing not implemented')
else:
print("Latent variable dim : " + str(opt.latent))
netEn, netDe, netD, netD2, trainerEn, trainerDe, trainerD, trainerD2 = set_network(opt.depth, ctx, opt.lr, opt.beta1,opt.ndf, opt.ngf,opt.latent, opt.append)
if opt.graphvis:
print(netG)
print('training')
print(opt.epochs)
loss_vec = train(opt.pool_size, opt.epochs, train_data,val_data, ctx, netEn, netDe, netD, netD2, trainerEn, trainerDe, trainerD, trainerD2, opt.lambda1, opt.batch_size, opt.expname, opt.append, useAE = useAE)
plt.gcf().clear()
fig, ax1 = plt.subplots()
ax1.plot(loss_vec[2], label="R", alpha= 0.7)
ax2 = ax1.twinx()
ax2.plot(loss_vec[0], label="Dr", alpha = 0.7)
ax2.plot(loss_vec[4], label="Dl", alpha = 0.7)
ax2.plot(loss_vec[1], label="Gr", alpha=0.7)
ax2.plot(loss_vec[5], label="Gl", alpha=0.7)
ax2.plot(loss_vec[3], label="Accr", alpha = 0.7)
ax2.plot(loss_vec[6], label="Accl", alpha = 0.7)
plt.legend()
plt.savefig('outputs/'+opt.expname+'_loss.png')
return inclasses
def main(opt):
if opt.seed != -1:
random.seed(opt.seed)
ctx = mx.gpu() if opt.use_gpu else mx.cpu()
inclasspaths, inclasses = dload.loadPaths(opt)
train_data, val_data = load_image.load_image(inclasspaths, opt)
print('Data loading done.')
networks = models.set_network(opt, ctx, False)
print('training')
# train networks based on opt.ntype(1 - AE 2 - ALOCC 3 - latentD 4 - adnov)
if opt.ntype == 4:
loss_vec = andgan.trainadnov(opt, train_data, val_data, ctx, networks)
elif opt.ntype == 2:
loss_vec = andgan.traincvpr18(opt, train_data, val_data, ctx, networks)
elif opt.ntype == 1:
loss_vec = andgan.trainAE(opt, train_data, val_data, ctx, networks)
plotloss(loss_vec, 'outputs/' + opt.expname + '_loss.png')
return inclasses
def save_mean(dataset,
datapath,
expname,
batch_size,
classes,
img_wd=61,
img_ht=61):
inclasspaths, inclasses = dload.loadPaths(dataset, datapath, expname,
batch_size + 1, classes)
for idx, img in enumerate(inclasspaths):
img_arr = mx.image.imread(img).astype(np.float32) / 127.5 - 1
img_arr = mx.image.imresize(img_arr, img_wd, img_ht)
img_arr = mx.nd.transpose(img_arr, (2, 0, 1))
if idx == 0:
mean_image = img_arr
else:
mean_image = (mean_image * float(idx) + img_arr) / (float(idx) +
1.0)
np.save("mean.npy", mean_image.asnumpy())
return mean_image
def main(opt):
if opt.useAE == 1:
useAE = True
else:
useAE = False
if opt.seed != -1:
random.seed(opt.seed)
ctx = mx.gpu() if opt.use_gpu else mx.cpu()
inclasspaths, inclasses = dload.loadPaths(opt.dataset, opt.datapath,
opt.expname, opt.batch_size + 1,
opt.classes)
train_data, val_data = load_image.load_image(inclasspaths, opt.batch_size,
opt.img_wd, opt.img_ht,
opt.noisevar)
print('Data loading done.')
if opt.istest:
testclasspaths = []
testclasslabels = []
if opt.istest:
filename = '_testlist.txt'
elif opt.isvalidation:
filename = '_trainlist.txt'
else:
filename = '_validationlist.txt'
filename = '_trainlist.txt'
with open(opt.dataset + "_" + opt.expname + filename, 'r') as f:
for line in f:
testclasspaths.append(line.split(' ')[0])
if int(line.split(' ')[1]) == -1:
testclasslabels.append(0)
else:
testclasslabels.append(1)
test_data = load_image.load_test_images(testclasspaths,
testclasslabels,
opt.batch_size, opt.img_wd,
opt.img_ht, ctx, opt.noisevar)
netG, netD, trainerG, trainerD = set_network(opt.depth, ctx, 0, 0,
opt.ndf, opt.ngf,
opt.append)
netG.load_params('checkpoints/' + opt.expname + '_' + str(opt.epochs) +
'_G.params',
ctx=ctx)
netD.load_params('checkpoints/' + opt.expname + '_' + str(opt.epochs) +
'_D.params',
ctx=ctx)
lbllist = []
scorelist1 = []
scorelist2 = []
scorelist3 = []
scorelist4 = []
test_data.reset()
count = 0
for batch in (test_data):
count += 1
real_in = batch.data[0].as_in_context(ctx)
real_out = batch.data[1].as_in_context(ctx)
lbls = batch.label[0].as_in_context(ctx)
outnn = (netG(real_out))
out_concat = nd.concat(real_out, outnn,
dim=1) if opt.append else outnn
output4 = nd.mean((netD(out_concat)), (1, 3, 2)).asnumpy()
out = (netG(real_in))
out_concat = nd.concat(real_in, out, dim=1) if opt.append else out
output = netD(out_concat) #Denoised image
output3 = nd.mean(out - real_out,
(1, 3, 2)).asnumpy() #denoised-real
output = nd.mean(output, (1, 3, 2)).asnumpy()
out_concat = nd.concat(real_out, real_out,
dim=1) if opt.append else real_out
output2 = netD(out_concat) #Image with no noise
output2 = nd.mean(output2, (1, 3, 2)).asnumpy()
lbllist = lbllist + list(lbls.asnumpy())
scorelist1 = scorelist1 + list(output)
scorelist2 = scorelist2 + list(output2)
scorelist3 = scorelist3 + list(output3)
scorelist4 = scorelist4 + list(output4)
fake_img1 = nd.concat(real_in[0], real_out[0], out[0], outnn[0], dim=1)
fake_img2 = nd.concat(real_in[1], real_out[1], out[1], outnn[1], dim=1)
fake_img3 = nd.concat(real_in[2], real_out[2], out[2], outnn[2], dim=1)
fake_img4 = nd.concat(real_in[3], real_out[3], out[3], outnn[3], dim=1)
fake_img = nd.concat(fake_img1, fake_img2, fake_img3, fake_img4, dim=2)
#print(np.shape(fake_img))
visual.visualize(fake_img)
plt.savefig('outputs/T_' + opt.expname + '_' + str(count) + '.png')
'''
fpr, tpr, _ = roc_curve(lbllist, scorelist1, 1)
roc_auc1 = auc(fpr, tpr)
fpr, tpr, _ = roc_curve(lbllist, scorelist2, 1)
roc_auc2 = auc(fpr, tpr)
fpr, tpr, _ = roc_curve(lbllist, scorelist3, 1)
roc_auc3 = auc(fpr, tpr)
fpr, tpr, _ = roc_curve(lbllist, scorelist4, 1)
roc_auc4 = auc(fpr, tpr)
return([roc_auc1, roc_auc2, roc_auc3, roc_auc4])
'''
return ([0, 0, 0, 0])
else:
netG, netD, trainerG, trainerD = set_network(opt.depth, ctx, opt.lr,
opt.beta1, opt.ndf,
opt.ngf, opt.append)
if opt.graphvis:
print(netG)
print('training')
print(opt.epochs)
loss_vec = train(opt.pool_size,
opt.epochs,
train_data,
val_data,
ctx,
netG,
netD,
trainerG,
trainerD,
opt.lambda1,
opt.batch_size,
opt.expname,
opt.append,
useAE=useAE)
plt.gcf().clear()
plt.plot(loss_vec[0], label="D", alpha=0.7)
plt.plot(loss_vec[1], label="G", alpha=0.7)
plt.plot(loss_vec[2], label="R", alpha=0.7)
plt.plot(loss_vec[3], label="Acc", alpha=0.7)
plt.legend()
plt.savefig('outputs/' + opt.expname + '_loss.png')
return inclasses