def main():
data = mnist()[:2] # ignore test split
model = Model(shape=[784])
if torch.cuda.is_available():
model = model.cuda()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
os.makedirs('images_nfs', exist_ok=True)
train_curve, val_curve = [], []
for epoch in range(ARGS.epochs):
bpds = run_epoch(model, data, optimizer)
train_bpd, val_bpd = bpds
train_curve.append(train_bpd)
val_curve.append(val_bpd)
print(
"[Epoch {epoch}] train bpd: {train_bpd} val_bpd: {val_bpd}".format(
epoch=epoch, train_bpd=train_bpd, val_bpd=val_bpd))
# model.eval()
# model.plot_samples(5)
# model.train()
# save model
if epoch % 10 == 0:
torch.save(model, "NF_epoch_" + str(epoch))
save_bpd_plot(train_curve, val_curve, 'nfs_bpd.pdf')
# save final model
torch.save(model, "NF_final")
def main():
data = mnist()[:2] # ignore test split
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model = Model(shape=[784], device=device).to(device)
if torch.cuda.is_available():
model = model.cuda()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
os.makedirs('images_nfs', exist_ok=True)
train_curve, val_curve = [], []
for epoch in range(ARGS.epochs):
bpds = run_epoch(model, data, optimizer, device)
train_bpd, val_bpd = bpds
train_curve.append(train_bpd)
val_curve.append(val_bpd)
print(
"[Epoch {epoch}] train bpd: {train_bpd} val_bpd: {val_bpd}".format(
epoch=epoch, train_bpd=train_bpd, val_bpd=val_bpd))
# --------------------------------------------------------------------
# Add functionality to plot samples from model during training.
# You can use the make_grid functionality that is already imported.
# Save grid to images_nfs/
# --------------------------------------------------------------------
# if epoch == 0 or epoch == 20 or epoch == ARGS.epochs -1:
# img = model.sample(25).detach().view(25, 1, 28, 28)
# grid = make_grid(img, nrow=5, normalize=True).permute(1, 2, 0).detach().cpu().numpy()
# plt.imsave('images_nfs/nfs_{}.png'.format(epoch), grid)
save_bpd_plot(train_curve, val_curve, 'nfs_bpd.pdf')
def main():
device = torch.device(ARGS.device)
data = mnist()[:2] # ignore test split
w = 28
model = Model(shape=[w**2]).to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
os.makedirs('figures', exist_ok=True)
train_curve, val_curve = [], []
for epoch in range(ARGS.epochs):
bpds = run_epoch(model, data, optimizer, device)
train_bpd, val_bpd = bpds
train_curve.append(train_bpd)
val_curve.append(val_bpd)
print("[Epoch {epoch}] train bpd: {train_bpd} val_bpd: {val_bpd}".format(
epoch=epoch, train_bpd=train_bpd, val_bpd=val_bpd))
# SAMPLING
imgs = model.sample(10).detach().cpu().view(10, 1, w, w)
save_image(imgs, f"figures/nf_{epoch}.png", nrow=5, normalize=True)
torch.save({'train': train_curve, 'val': val_curve}, 'nf_curves.pt')
torch.save(model.state_dict(), "nf_model.pt")
def main():
data = mnist()[:2] # ignore test split
model = Model(shape=[784])
if torch.cuda.is_available():
model = model.cuda()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
# os.makedirs('images_nfs', exist_ok=True)
train_curve, val_curve = [], []
for epoch in range(ARGS.epochs):
bpds = run_epoch(model, data, optimizer)
train_bpd, val_bpd = bpds
train_curve.append(train_bpd)
val_curve.append(val_bpd)
print(f'[{datetime.now().strftime("%Y-%m-%d %H:%M")}] Epoch {epoch:02d}, train bpd: {train_bpd:07f}, val_bpd: {val_bpd:07f}')
# --------------------------------------------------------------------
# Add functionality to plot samples from model during training.
# You can use the make_grid functionality that is already imported.
# Save grid to images_nfs/
# --------------------------------------------------------------------
save_images(model, epoch)
torch.save(model.state_dict(), RESULTS_DIR / f'{model.__class__.__name__}.pt')
save_bpd_plot(train_curve, val_curve, RESULTS_DIR / 'nf_bpd.png')
def main(args):
flags = ('epochs', 'lr')
(epochs, lr) = itemgetter(*flags)(vars(args))
data = mnist()[:2] # ignore test split
model = Model(shape=[x_dim])
optimizer = torch.optim.Adam(model.parameters(), lr=lr)
path = 'nf'
os.makedirs(path, exist_ok=True)
train_curve, val_curve = [], []
for epoch in range(epochs):
(train_bpd, val_bpd) = run_epoch(model, data, optimizer, epoch)
train_curve.append(train_bpd)
val_curve .append( val_bpd)
print(f'[Epoch {epoch}] train bpd: {train_bpd} val_bpd: {val_bpd}')
# --------------------------------------------------------------------
# Add functionality to plot samples from model during training.
# You can use the make_grid functionality that is already imported.
# Save grid to nf/
# --------------------------------------------------------------------
save_images(model, epoch, path)
save_bpd_plot(train_curve, val_curve, f'{path}/nfs_bpd.png')
torch.save(model.state_dict(), f'{path}/model_{epoch}.pt')
def main():
data = mnist()[:2] # ignore test split
model = Model(shape=[784]).to(ARGS.device)
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
os.makedirs('images_nfs', exist_ok=True)
train_curve, val_curve = [], []
for epoch in range(ARGS.epochs):
train_bpd, val_bpd = run_epoch(model, data, optimizer)
train_curve.append(train_bpd)
val_curve.append(val_bpd)
print(
"[Epoch {epoch}] train bpd: {train_bpd} val_bpd: {val_bpd}".format(
epoch=epoch, train_bpd=train_bpd, val_bpd=val_bpd))
# --------------------------------------------------------------------
# Add functionality to plot samples from model during training.
# You can use the make_grid functionality that is already imported.
# Save grid to images_nfs/
# --------------------------------------------------------------------
sample = model.sample(64).view(-1, 1, 28, 28)
save_image(sample,
f"images_nfs/sample_{epoch:03d}.png",
nrow=8,
normalize=True)
save_bpd_plot(train_curve, val_curve, 'nfs_bpd.png')
save_bpd_plot(train_curve, val_curve, 'nfs_bpd.pdf')
def main():
data = mnist()[:2] # ignore test split
model = Model(shape=[784]).to(ARGS.device)
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
start = datetime.now().strftime("%Y-%m-%d_%H:%M")
f_train = open('bpd_nf/train_' + start + '.txt', 'w')
f_valid = open('bpd_nf/valid_' + start + '.txt', 'w')
# os.makedirs('images_nfs', exist_ok=True)
train_curve, val_curve = [], []
for epoch in range(ARGS.epochs):
bpds = run_epoch(model, data, optimizer, ARGS.device)
train_bpd, val_bpd = bpds
# train_curve.append(train_bpd)
# val_curve.append(val_bpd)
print(
"[Epoch {epoch}] train bpd: {train_bpd} val_bpd: {val_bpd}".format(
epoch=epoch, train_bpd=train_bpd, val_bpd=val_bpd))
f_train.write(', ' + str(train_bpd))
f_valid.write(', ' + str(val_bpd))
# --------------------------------------------------------------------
# Add functionality to plot samples from model during training.
# You can use the make_grid functionality that is already imported.
# Save grid to images_nfs/
# --------------------------------------------------------------------
f_train.close()
f_valid.close()
def main(epochs, timestamp, _run):
data = mnist()[:2] # ignore test split
model = Model(shape=[IMG_PIXELS]).to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
for epoch in range(1, epochs + 1):
# Save samples at beginning, 50% and 100% of training
if int(100 * epoch / epochs) in [int(100 / epochs), 50, 100]:
fname = 'nf_{:d}.png'.format(epoch)
save_samples(model, fname)
bpds = run_epoch(model, data, optimizer)
train_bpd, val_bpd = bpds
print(
"[Epoch {epoch}] train bpd: {train_bpd} val_bpd: {val_bpd}".format(
epoch=epoch, train_bpd=train_bpd, val_bpd=val_bpd))
_run.log_scalar('train_bpd', train_bpd, epoch)
_run.log_scalar('val_pbd', val_bpd, epoch)
# Save model
fname = str(timestamp) + '.pt'
model_path = os.path.join(os.path.dirname(__file__), 'saved', fname)
torch.save(model.state_dict(), model_path)
print('Saved model to {}'.format(model_path))
def main():
data = mnist()[:2] # ignore test split
model = Model(shape=[784])
if torch.cuda.is_available():
model = model.cuda()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
os.makedirs('images_nfs', exist_ok=True)
train_curve, val_curve = [], []
for epoch in range(ARGS.epochs):
bpds = run_epoch(model, data, optimizer)
train_bpd, val_bpd = bpds
train_curve.append(train_bpd)
val_curve.append(val_bpd)
print(
"[Epoch {epoch}] train bpd: {train_bpd} val_bpd: {val_bpd}".format(
epoch=epoch, train_bpd=train_bpd, val_bpd=val_bpd))
generated_imgs = model.sample(100)
to_show = generated_imgs.view(-1, 1, 28, 28)
save_image(to_show,
'images_nfs/{}.png'.format(epoch),
nrow=10,
normalize=True)
save_bpd_plot(train_curve, val_curve, 'nfs_bpd.pdf')
def main():
writer = NfWriter(ARGS.output_dir)
data = mnist()[:2] # ignore test split
model = Model(shape=[784])
if torch.cuda.is_available():
model = model.cuda()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
os.makedirs('images_nfs', exist_ok=True)
train_curve, val_curve = [], []
for epoch in range(ARGS.epochs):
bpds = run_epoch(model, data, optimizer)
train_bpd, val_bpd = bpds
train_curve.append(train_bpd)
val_curve.append(val_bpd)
print(
"[Epoch {epoch}] train bpd: {train_bpd} val_bpd: {val_bpd}".format(
epoch=epoch, train_bpd=train_bpd, val_bpd=val_bpd))
writer.save_stats(train_bpd, val_bpd)
writer.save_bpd_plot()
imgs_gen = model.sample(25).detach().reshape(25, 1, 28, 28).cpu()
writer.save_images(imgs_gen, epoch)
def main():
data = mnist()[:2] # ignore test split
model = Model(shape=[784])
if torch.cuda.is_available():
model = model.cuda()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
os.makedirs('images_nfs', exist_ok=True)
train_curve, val_curve = [], []
for epoch in range(ARGS.epochs):
print(device, epoch)
bpds = run_epoch(model, data, optimizer)
train_bpd, val_bpd = bpds
train_curve.append(train_bpd)
val_curve.append(val_bpd)
print("[Epoch {epoch}] train bpd: {train_bpd} val_bpd: {val_bpd}".format(
epoch=epoch, train_bpd=train_bpd, val_bpd=val_bpd))
# sample print
manifold = model.sample(25)
manifold = manifold.view(-1, 1, 28, 28)
save_image(manifold,
'images_nfs/NFmania' + str(epoch) + '.png',
nrow=5, normalize=True)
# --------------------------------------------------------------------
# Add functionality to plot samples from model during training.
# You can use the make_grid functionality that is already imported.
# Save grid to images_nfs/
# --------------------------------------------------------------------
save_bpd_plot(train_curve, val_curve, 'nfs_bpd.pdf')
torch.save(model.state_dict(), 'images_nfs/NFstate.pt')
def main():
data = mnist()[:2] # ignore test split
model = Model(shape=[784])
if torch.cuda.is_available():
model = model.cuda()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
os.makedirs('images_nfs', exist_ok=True)
train_curve, val_curve = [], []
for epoch in range(ARGS.epochs):
bpds = run_epoch(model, data, optimizer)
train_bpd, val_bpd = bpds
train_curve.append(train_bpd)
val_curve.append(val_bpd)
print("[Epoch {epoch}] train bpd: {train_bpd} val_bpd: {val_bpd}".format(
epoch=epoch, train_bpd=train_bpd, val_bpd=val_bpd))
# --------------------------------------------------------------------
# Add functionality to plot samples from model during training.
# You can use the make_grid functionality that is already imported.
# Save grid to images_nfs/
# --------------------------------------------------------------------
save_bpd_plot(train_curve, val_curve, 'nfs_bpd.pdf')
def main():
if (ARGS.t):
data = mnist(root=ARGS.dpath, batch_size=16)[:2] # ignore test split
else:
data = mnist(root=ARGS.dpath)[:2] # ignore test split
device = torch.device(ARGS.device)
model = Model(shape=[784])
model.to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
optimizer, ARGS.epochs + 10)
os.makedirs('images_nfs', exist_ok=True)
NO_IMAGES = 25
train_curve, val_curve = [], []
for epoch in range(ARGS.epochs):
bpds = run_epoch(model, data, optimizer, ARGS.t, device)
train_bpd, val_bpd = bpds
train_curve.append(train_bpd)
val_curve.append(val_bpd)
scheduler.step()
print(
"[Epoch {epoch}] train bpd: {train_bpd} val_bpd: {val_bpd}, LR: {lr}"
.format(epoch=epoch,
train_bpd=train_bpd,
val_bpd=val_bpd,
lr=optimizer.state_dict()['param_groups'][0]['lr']))
# --------------------------------------------------------------------
# Add functionality to plot samples from model during training.
# You can use the make_grid functionality that is already imported.
# Save grid to images_nfs/
# --------------------------------------------------------------------
samples = model.sample(NO_IMAGES)
grid = make_grid(samples.cpu().view(NO_IMAGES, 1, 28,
-1).permute(0, 1, 3, 2),
nrow=5,
normalize=True)
plt.imshow(grid.permute(2, 1, 0).numpy())
plt.title('Sample generated image, epoch {}'.format(epoch))
plt.savefig('images_nfs/epoch_{}.png'.format(epoch))
save_bpd_plot(train_curve, val_curve, 'nfs_bpd.pdf')
def main():
# Create output image directory
os.makedirs(ARGS.gen_image_path, exist_ok=True)
# Get data --ignore test split
data = mnist()[:2]
# Init model
model = nn.DataParallel(
Model(shape=[28 * 28], n_flows=ARGS.n_flows).to(device))
# Init optimizer
optimizer = torch.optim.Adam(model.parameters(),
lr=ARGS.lr,
betas=(ARGS.b1, ARGS.b2),
eps=1e-07)
# Clip grads
nn.utils.clip_grad_norm(model.parameters(), ARGS.max_grad_norm)
train_curve, val_curve = [], []
for epoch in range(ARGS.epochs):
# Run one epoch and get the bpds
bpds = run_epoch(model, data, optimizer)
train_bpd, val_bpd = bpds
# Save bpds to lists
train_curve.append(train_bpd)
val_curve.append(val_bpd)
print(
'Epoch [{:4d}/{:4d}] | Train BPD: {:6.2f} | Validation BPD: {:6.2f}'
.format(epoch + 1, ARGS.epochs, train_bpd, val_bpd))
# --------------------------------------------------------------------
# Plot samples from model during training.
# --------------------------------------------------------------------
# Samle image
X = model.module.sample(ARGS.sample_size)
# Save sampled image
save_image(X.data.view(-1, 1, 28, 28),
ARGS.gen_image_path + 'nf_{}.png'.format(epoch + 1),
nrow=int(math.sqrt(ARGS.sample_size)),
normalize=True)
# save_bpd_plot(train_curve, val_curve, 'nfs_bpd_pdf_{}'.format(epoch+1))
save_bpd_plot(train_curve,
val_curve,
'nfs_bpd_pdf_{}'.format(ARGS.epochs + 2),
dpi=300)
def main(ARGS):
# load data:
data = mnist()[:2] # ignore test split
# load device
device = get_device(ARGS)
if device == 'cuda':
torch.Tensor = torch.cuda.FloatTensor
# print args:
print_args(ARGS)
print(f"Device used: {device}")
# load model
model = Model(shape=[784], device=device).to(device)
# load optimizer
optimizer = torch.optim.Adam(model.parameters(), lr=ARGS.lr)
# make directory to save images
os.makedirs(ARGS.save_path + 'images_nfs', exist_ok=True)
train_curve, dev_curve = [], []
for epoch in range(ARGS.epochs):
path = ARGS.save_path + 'images_nfs' + "/"
save_images(model, epoch, path)
train_bpd, val_bpd = run_epoch(model, data, optimizer, device)
train_curve.append(train_bpd)
dev_curve.append(val_bpd)
print(
"[Epoch {epoch}] train bpd: {train_bpd:.5f} val_bpd: {val_bpd:.5f}"
.format(epoch=epoch, train_bpd=train_bpd, val_bpd=val_bpd))
# save stats
stats = {"train loss": train_curve, "dev_loss": dev_curve}
np.save(ARGS.save_path + "stats.npy", stats)
# save model
torch.save(model.state_dict(),
ARGS.save_path + model.__class__.__name__ + ".pt")
save_bpd_plot(train_curve, dev_curve, ARGS.save_path + 'nfs_bpd.pdf')
def main():
data = mnist()[:2] # ignore test split
model = Model(shape=[784])
if torch.cuda.is_available():
model = model.cuda()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
os.makedirs('images_nfs', exist_ok=True)
train_curve, val_curve = [], []
for epoch in range(ARGS.epochs):
bpds = run_epoch(model, data, optimizer)
train_bpd, val_bpd = bpds
train_curve.append(train_bpd)
val_curve.append(val_bpd)
print(
"[Epoch {epoch}] train bpd: {train_bpd} val_bpd: {val_bpd}".format(
epoch=epoch, train_bpd=train_bpd, val_bpd=val_bpd))
# --------------------------------------------------------------------
# Add functionality to plot samples from model during training.
# You can use the make_grid functionality that is already imported.
# Save grid to images_nfs/
# --------------------------------------------------------------------
sampled_ims = model.sample(25).detach()
sampled_ims = sampled_ims.reshape(25, 1, 28, 28).cpu()
grid_img = make_grid(sampled_ims, nrow=5, normalize=True).detach()
plt.title('Sampled Images')
plt.imshow(grid_img.permute(1, 2, 0), ) # , (1,2,0)))
title = 'sampled_img_nvp' + str(epoch) + '.png'
plt.savefig(title, dpi=100)
save_bpd_plot(train_curve, val_curve, 'nfs_bpd.pdf')
name_model = 'real_nvp.pickle'
torch.save(model.state_dict(), name_model)
def main():
data = mnist()[:2] # ignore test split
model = Model(shape=[784]).to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
os.makedirs('images_nfs', exist_ok=True)
train_curve, val_curve = [], []
for epoch in range(ARGS.epochs):
bpds = run_epoch(model, data, optimizer)
train_bpd, val_bpd = bpds
train_curve.append(train_bpd)
val_curve.append(val_bpd)
print(
"[Epoch {epoch}] train bpd: {train_bpd} val_bpd: {val_bpd}".format(
epoch=epoch, train_bpd=train_bpd, val_bpd=val_bpd))
# --------------------------------------------------------------------
# Add functionality to plot samples from model during training.
# You can use the make_grid functionality that is already imported.
# Save grid to images_nfs/
# --------------------------------------------------------------------
if epoch % 2 == 0 or epoch == ARGS.epochs - 1:
samples = model.sample(25)
samples = samples.view(-1, 1, 28, 28)
arrays = make_grid(samples, nrow=5, normalize=True)[0]
img_path = os.path.join(
os.path.dirname(__file__), 'images_nfs',
"sample_{}_{}.png".format(epoch, int(time.time())))
print("saving image", img_path)
# save_image(samples, img_path,nrow=5,normalize=True)
if arrays.is_cuda:
arrays = arrays.cpu()
plt.imsave(img_path, arrays.detach().numpy(), cmap="binary")
save_bpd_plot(train_curve, val_curve, 'nfs_bpd.pdf')
def main():
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
# Print all configs to confirm parameter settings
print_flags()
data = mnist()[:2] # ignore test split
# Create output directories
os.makedirs('./images/nf', exist_ok=True)
model = Model(shape=[784], device=device).to(device)
if torch.cuda.is_available():
model = model.cuda()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
train_curve, val_curve = [], []
for epoch in range(ARGS.epochs):
bpds = run_epoch(model, data, optimizer, device)
train_bpd, val_bpd = bpds
train_curve.append(train_bpd)
val_curve.append(val_bpd)
print(
"[Epoch {epoch}] train bpd: {train_bpd} val_bpd: {val_bpd}".format(
epoch=epoch, train_bpd=train_bpd, val_bpd=val_bpd))
# --------------------------------------------------------------------
# Add functionality to plot samples from model during training.
# You can use the make_grid functionality that is already imported.
# Save grid to images/nfs/
# --------------------------------------------------------------------
im_samples = model.sample(25)
save_image(im_samples.view(im_samples.shape[0], 1, 28, 28),
'./images/nf/{}.png'.format(epoch),
nrow=5,
normalize=True)
save_bpd_plot(train_curve, val_curve, './images/nf/nfs_bpd.png')
save_bpd_plot(train_curve, val_curve, './images/nf/nfs_bpd.eps')
def main():
device = torch.device(ARGS.device)
data = mnist()[:2] # ignore test split
model = Model(shape=[784]).to(device)
# if torch.cuda.is_available():
# model = model.cuda()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
os.makedirs('images_nfs', exist_ok=True)
train_curve, val_curve = [], []
for epoch in range(ARGS.epochs):
bpds = run_epoch(model, data, optimizer, device)
train_bpd, val_bpd = bpds
train_curve.append(train_bpd)
val_curve.append(val_bpd)
print(
"[Epoch {epoch}] train bpd: {train_bpd} val_bpd: {val_bpd}".format(
epoch=epoch, train_bpd=train_bpd, val_bpd=val_bpd))
# --------------------------------------------------------------------
# Add functionality to plot samples from model during training.
# You can use the make_grid functionality that is already imported.
# Save grid to images_nfs/
# --------------------------------------------------------------------
generated_img = model.sample(ARGS.n_samples)
generated_img = generated_img.reshape(-1, 1, 28, 28)
save_image(generated_img,
f"images_nfs/grid_Epoch{epoch}.png",
nrow=int(math.sqrt(ARGS.n_samples)),
padding=2,
normalize=True)
save_bpd_plot(train_curve, val_curve, 'images_nfs/nfs_bpd.pdf')
torch.save(model.state_dict(), ARGS.save_model)
save_bpd_plot(train_curve, val_curve, 'images_nfs/nfs_bpd.pdf')
def main():
data = mnist()[:2] # ignore test split
device = ARGS.device
n_samples = ARGS.n_samples
model = Model(shape=[784]).to(device)
if torch.cuda.is_available():
model = model.cuda()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
os.makedirs('images_nfs', exist_ok=True)
plot_grid(model, n_samples, 0)
train_curve, val_curve = [], []
for epoch in range(ARGS.epochs):
bpds = run_epoch(model, data, optimizer, device)
train_bpd, val_bpd = bpds
train_curve.append(train_bpd)
val_curve.append(val_bpd)
print("[Epoch {epoch}] train bpd: {train_bpd} val_bpd: {val_bpd}".format(
epoch=epoch, train_bpd=train_bpd, val_bpd=val_bpd))
# --------------------------------------------------------------------
# Add functionality to plot samples from model during training.
# You can use the make_grid functionality that is already imported.
# Save grid to images_nfs/
# --------------------------------------------------------------------
# Same procedure I already implemented in the VAE file
if epoch % 5 == 0 or epoch == ARGS.epochs - 1:
plot_grid(model, n_samples, epoch + 1)
save_bpd_plot(train_curve, val_curve, 'nfs_bpd.png')
torch.save(model, "trained_norm_flow.pth")
def main():
data = mnist()[:2] # ignore test split
model = Model(shape=[784])
if torch.cuda.is_available():
model = model.cuda()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
os.makedirs('images_nfs', exist_ok=True)
train_curve, val_curve = [], []
epoch_times = []
save_images(model, 0, 0, 0)
for epoch in range(ARGS.epochs):
start_time = time.time() # track time to know how long an epoch takes
bpds = run_epoch(model, data, optimizer) # get bpd
train_bpd, val_bpd = bpds
train_curve.append(train_bpd) # create beautiful curves
val_curve.append(val_bpd)
timeofepoch = time.time() - start_time
epoch_times.append(timeofepoch)
average_epoch_time = np.mean(epoch_times)
# track time and performance ------------------------------
print(
"[Epoch {epoch}] train bpd: {train_bpd} val_bpd: {val_bpd}. Epoch took {timeofepoch} seconds, approx {minutestogo} minutes to go".format(
epoch=epoch, train_bpd=train_bpd, val_bpd=val_bpd,
timeofepoch=timeofepoch,
minutestogo=((ARGS.epochs - epoch) * average_epoch_time) / 60
))
# ---------------------------------------------------------
save_images(model, epoch, train_bpd, val_bpd)
save_bpd_plot(train_curve, val_curve, 'nfs_bpd.pdf')
def main(ARGS):
data = mnist()[:2] # ignore test split
model = Model(shape=[784])
if torch.cuda.is_available():
model = model.cuda()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
os.makedirs('results/nf/', exist_ok=True)
train_curve, val_curve = [], []
for epoch in range(ARGS.epochs):
bpds = run_epoch(model, data, optimizer)
train_bpd, val_bpd = bpds
train_curve.append(train_bpd)
val_curve.append(val_bpd)
print(
"[Epoch {epoch}] train bpd: {train_bpd} val_bpd: {val_bpd}".format(
epoch=epoch, train_bpd=train_bpd, val_bpd=val_bpd))
# --------------------------------------------------------------------
# Add functionality to plot samples from model during training.
# You can use the make_grid functionality that is already imported.
# Save grid to images_nfs/
# --------------------------------------------------------------------
if epoch in (0, int(ARGS.epochs // 2), ARGS.epochs - 1):
sample_imgs = model.sample(100)
sample_imgs = sample_imgs.view(-1, 1, 28, 28)
imgs_grid = make_grid(sample_imgs, nrow=10,
normalize=True).cpu().numpy()
plt.imsave('results/nf/sample_imgs_epoch{}.png'.format(epoch),
np.transpose(imgs_grid, (1, 2, 0)))
save_bpd_plot(train_curve, val_curve, 'results/nf/nfs_bpd.png')
required=False)
args = parser.parse_args()
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# load dataset
if args.ds == 'mnist':
num_features = 28 * 28
num_classes = 10
num_training = 60000
train_dataset = mnist(root='./mnist/',
download=True,
train_or_not=True,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))
]),
partial_type=args.partial_type,
partial_rate=args.partial_rate)
test_dataset = mnist(root='./mnist/',
download=True,
train_or_not=False,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))
]),
partial_type=args.partial_type,
partial_rate=args.partial_rate)
if args.ds == 'fashion':
