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,
}
