def main(args):
torch.cuda.set_device(args.cuda)
print("Loading data")
dataset = args.data.rstrip('/').split('/')[-1]
train_iter, test_iter = get_adult(args.data, args.batch_size,
args.nogender, args.test_size)
for _, (batch, _, _) in enumerate(train_iter):
n_features = batch.size(-1)
break
encoder = Classifier(n_features, args.code_dim, args.hidden)
rbf = gp.kernels.RBF(input_dim=args.code_dim,
lengthscale=torch.ones(args.code_dim))
deep_kernel = gp.kernels.Warping(rbf, iwarping_fn=encoder)
batches = []
for i, (data, _, _) in enumerate(train_iter):
batches.append(data)
# if i >= ((args.num_inducing - 1) // args.batch_size):
# break
X = torch.cat(batches)[:].clone()
Xu = torch.cat(batches)[:args.num_inducing].clone()
likelihood = gp.likelihoods.MultiClass(num_classes=2)
latent_shape = torch.Size([2])
gpmodule = gp.models.VariationalSparseGP(X=X,
y=None,
kernel=deep_kernel,
Xu=Xu,
likelihood=likelihood,
latent_shape=latent_shape,
whiten=True).to(args.device)
optimizer = torch.optim.Adam(gpmodule.parameters(), lr=args.lr)
elbo = infer.JitTraceMeanField_ELBO if args.jit else infer.TraceMeanField_ELBO(
)
criterion = elbo.differentiable_loss
start_epoch = 1
print('\nStart training')
try:
for epoch in range(start_epoch, args.epochs):
clf_loss, clf_acc = train(args, train_iter, gpmodule, optimizer,
criterion, epoch)
print('-' * 90)
meta = "| epoch {:2d} ".format(epoch)
print(meta + "| Train loss {:5.2f} | Train acc {:5.2f}".format(
clf_loss, clf_acc))
clf_acc = test(args, test_iter, gpmodule)
print(
len(meta) * " " +
"| Test loss {:5.2f} | Test accuracy {:5.2f}".format(
clf_loss, clf_acc))
except KeyboardInterrupt:
print('-' * 50)
print('Quit training')
def train(self,
num_epochs=5,
num_iters=60,
batch_size=1000,
learning_rate=0.01):
optimizer = torch.optim.Adam(self.parameters(), lr=learning_rate)
loss_fn = infer.TraceMeanField_ELBO().differentiable_loss
for i in range(num_epochs):
train(self.X, self.y, self, optimizer, loss_fn, batch_size,
num_iters, i)
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 train(self,
num_epochs=5,
num_iters=60,
batch_size=1000,
learning_rate=0.01):
optimizer = torch.optim.Adam(self.parameters(), lr=learning_rate)
loss_fn = infer.TraceMeanField_ELBO().differentiable_loss
self.loss = []
for i in range(num_epochs):
self.loss.append(
self.train_update(optimizer, loss_fn, batch_size, num_iters,
i))
self.loss = np.array(self.loss).reshape((-1, 1))
if self.calibrate:
print("Calibrating the trained model...")
calibration_indexes = np.random.choice(
list(range(self.X.shape[0])),
int(np.ceil(self.calibration_fraction * self.X.shape[0])))
y_uncalibrated = self.predict_survival(
self.X[calibration_indexes, :].detach().numpy(), calibrate=1)
y_raw = np.log((1 - y_uncalibrated) / y_uncalibrated)
self.calibration_constant = sigmoid_calibrate_survival_predictions(
self, y_raw)
print("Done training!")
else:
self.calibration_constant = 1