def main(args): train_loader = get_data_loader(dataset_name='MNIST', data_dir=args.data_dir, batch_size=args.batch_size, dataset_transforms=[transforms.Normalize((0.1307,), (0.3081,))], is_training_set=True, shuffle=True) test_loader = get_data_loader(dataset_name='MNIST', data_dir=args.data_dir, batch_size=args.batch_size, dataset_transforms=[transforms.Normalize((0.1307,), (0.3081,))], is_training_set=False, shuffle=True) cnn = CNN().cuda() if args.cuda else CNN() # optimizer in SVI just works with params which are active inside its model/guide scope; # so we need this helper to mark cnn's parameters active for each `svi.step()` call. def cnn_fn(x): return pyro.module("CNN", cnn)(x) # Create deep kernel by warping RBF with CNN. # CNN will transform a high dimension image into a low dimension 2D tensors for RBF kernel. # This kernel accepts inputs are inputs of CNN and gives outputs are covariance matrix of RBF on # outputs of CNN. kernel = gp.kernels.RBF(input_dim=10, lengthscale=torch.ones(10)).warp(iwarping_fn=cnn_fn) # init inducing points (taken randomly from dataset) Xu = next(iter(train_loader))[0][:args.num_inducing] # use MultiClass likelihood for 10-class classification problem likelihood = gp.likelihoods.MultiClass(num_classes=10) # Because we use Categorical distribution in MultiClass likelihood, we need GP model returns a list # of probabilities of each class. Hence it is required to use latent_shape = 10. # Turns on "whiten" flag will help optimization for variational models. gpmodel = gp.models.VariationalSparseGP(X=Xu, y=None, kernel=kernel, Xu=Xu, likelihood=likelihood, latent_shape=torch.Size([10]), num_data=60000, whiten=True) if args.cuda: gpmodel.cuda() optimizer = optim.Adam({"lr": args.lr}) svi = infer.SVI(gpmodel.model, gpmodel.guide, optimizer, infer.Trace_ELBO()) for epoch in range(1, args.epochs + 1): start_time = time.time() train(args, train_loader, gpmodel, svi, epoch) with torch.no_grad(): test(args, test_loader, gpmodel) print("Amount of time spent for epoch {}: {}s\n".format(epoch, int(time.time() - start_time)))
def main(args): data_dir = args.data_dir if args.data_dir is not None else get_data_directory(__file__) train_loader = get_data_loader(dataset_name='MNIST', data_dir=data_dir, batch_size=args.batch_size, dataset_transforms=[transforms.Normalize((0.1307,), (0.3081,))], is_training_set=True, shuffle=True) test_loader = get_data_loader(dataset_name='MNIST', data_dir=data_dir, batch_size=args.batch_size, dataset_transforms=[transforms.Normalize((0.1307,), (0.3081,))], is_training_set=False, shuffle=True) cnn = CNN() # Create deep kernel by warping RBF with CNN. # CNN will transform a high dimension image into a low dimension 2D tensors for RBF kernel. # This kernel accepts inputs are inputs of CNN and gives outputs are covariance matrix of RBF # on outputs of CNN. rbf = gp.kernels.RBF(input_dim=10, lengthscale=torch.ones(10)) deep_kernel = gp.kernels.Warping(rbf, iwarping_fn=cnn) # init inducing points (taken randomly from dataset) Xu = next(iter(train_loader))[0][:args.num_inducing] # use MultiClass likelihood for 10-class classification problem likelihood = gp.likelihoods.MultiClass(num_classes=10) # Because we use Categorical distribution in MultiClass likelihood, we need GP model returns # a list of probabilities of each class. Hence it is required to use latent_shape = 10. # Turns on "whiten" flag will help optimization for variational models. gpmodule = gp.models.VariationalSparseGP(X=Xu, y=None, kernel=deep_kernel, Xu=Xu, likelihood=likelihood, latent_shape=torch.Size([10]), num_data=60000, whiten=True) if args.cuda: gpmodule.cuda() optimizer = torch.optim.Adam(gpmodule.parameters(), lr=args.lr) elbo = infer.JitTraceMeanField_ELBO() if args.jit else infer.TraceMeanField_ELBO() loss_fn = elbo.differentiable_loss for epoch in range(1, args.epochs + 1): start_time = time.time() train(args, train_loader, gpmodule, optimizer, loss_fn, epoch) with torch.no_grad(): test(args, test_loader, gpmodule) print("Amount of time spent for epoch {}: {}s\n" .format(epoch, int(time.time() - start_time)))
def setup(args): pyro.set_rng_seed(args.rng_seed) train_loader = util.get_data_loader(dataset_name='MNIST', data_dir=DATA_DIR, batch_size=args.batch_size, is_training_set=True, shuffle=True) test_loader = util.get_data_loader(dataset_name='MNIST', data_dir=DATA_DIR, batch_size=args.batch_size, is_training_set=False, shuffle=True) global OUTPUT_DIR OUTPUT_DIR = os.path.join(RESULTS_DIR, args.impl) if not os.path.exists(OUTPUT_DIR): os.makedirs(OUTPUT_DIR) pyro.clear_param_store() return train_loader, test_loader
def setup(args): pyro.set_rng_seed(args.rng_seed) train_loader = util.get_data_loader(dataset_name='MNIST', data_dir=DATA_DIR, batch_size=args.batch_size, is_training_set=True, shuffle=True) test_loader = util.get_data_loader(dataset_name='MNIST', data_dir=DATA_DIR, batch_size=args.batch_size, is_training_set=False, shuffle=True) global OUTPUT_DIR OUTPUT_DIR = os.path.join(RESULTS_DIR, args.impl) if not os.path.exists(OUTPUT_DIR): os.makedirs(OUTPUT_DIR) pyro.clear_param_store() return train_loader, test_loader
def main(args): train_loader = get_data_loader(dataset_name='MNIST', data_dir='~/.data', batch_size=1000, is_training_set=True, shuffle=True) test_loader = get_data_loader(dataset_name='MNIST', data_dir='~/.data', batch_size=1000, is_training_set=False, shuffle=False) X = train_loader.dataset.data.reshape(-1, 784).float() / 255 y = train_loader.dataset.targets deepgp = DeepGP(X, y, num_classes=10) deepgp.train(args.num_epochs, args.num_iters, args.batch_size, args.learning_rate) test(test_loader, deepgp)
def load_mnist(root_path): loader = get_data_loader('MNIST', root_path) return { 'digits': loader.dataset.data.cpu().numpy(), 'labels': loader.dataset.targets }
def main(args): normalize = transforms.Normalize((0.1307, ), (0.3081, )) train_loader = get_data_loader(dataset_name='MNIST', data_dir=args.data_dir, batch_size=args.batch_size, dataset_transforms=[normalize], is_training_set=True, shuffle=True) test_loader = get_data_loader(dataset_name='MNIST', data_dir=args.data_dir, batch_size=args.batch_size, dataset_transforms=[normalize], is_training_set=False, shuffle=True) cnn = CNN().cuda() if args.cuda else CNN() # optimizer in SVI just works with params which are active inside # its model/guide scope; so we need this helper to # mark cnn's parameters active for each `svi.step()` call. def cnn_fn(x): return pyro.module("CNN", cnn)(x) # Create deep kernel by warping RBF with CNN. # CNN will transform a high dimension image into a low dimension 2D # tensors for RBF kernel. # This kernel accepts inputs are inputs of CNN and gives outputs are # covariance matrix of RBF on outputs of CNN. kernel = gp.kernels.RBF( input_dim=10, lengthscale=torch.ones(10)).warp(iwarping_fn=cnn_fn) # init inducing points (taken randomly from dataset) Xu = next(iter(train_loader))[0][:args.num_inducing] # use MultiClass likelihood for 10-class classification problem likelihood = gp.likelihoods.MultiClass(num_classes=10) # Because we use Categorical distribution in MultiClass likelihood, # we need GP model returns a list of probabilities of each class. # Hence it is required to use latent_shape = 10. # Turns on "whiten" flag will help optimization for variational models. gpmodel = gp.models.VariationalSparseGP(X=Xu, y=None, kernel=kernel, Xu=Xu, likelihood=likelihood, latent_shape=torch.Size([10]), num_data=60000, whiten=True) if args.cuda: gpmodel.cuda() # optimizer = optim.adam({"lr": args.lr}) optimizer = optim.Adam(lr=args.lr) # optimizer = get_optimizer(args) svi = infer.SVI(gpmodel.model, gpmodel.guide, optimizer, infer.Trace_ELBO()) for epoch in range(1, args.epochs + 1): start_time = time.time() train(args, train_loader, gpmodel, svi, epoch) with torch.no_grad(): test(args, test_loader, gpmodel) print("Amount of time spent for epoch {}: {}s\n".format( epoch, int(time.time() - start_time)))
def load_mnist(root_path): loader = get_data_loader("MNIST", root_path) return { "digits": loader.dataset.data.cpu().numpy(), "labels": loader.dataset.targets, }