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':