def setup_model(self):
patch_size = self.run_settings['patch_size']
# k1 = ckern.ConvRBF([28, 28], [patch_size, patch_size]) # Experiment was mistakenly run with no weighting
if self.run_settings["kernel1"] == "wconv":
k1 = ckern.WeightedConv(GPflow.kernels.RBF(25), [28, 28], [patch_size, patch_size])
elif self.run_settings['kernel1'] == "conv":
k1 = ckern.Conv(GPflow.kernels.RBF(25), [28, 28], [patch_size, patch_size])
else:
raise NotImplementedError("Unknown setting for `kernel1`.")
if self.run_settings['kernel2'] == "rbf":
k2 = GPflow.kernels.RBF(28 * 28) + GPflow.kernels.White(28 * 28)
elif self.run_settings['kernel2'] == "poly":
raise NotImplementedError("Look up what the poly was used in the paper Miguel sent you.")
elif self.run_settings['kernel2'] == "rbfpoly":
raise NotImplementedError("Look up what the poly was used in the paper Miguel sent you.")
else:
raise NotImplementedError("Unknown setting for `kernel2`.")
k2.white.variance = 1e-2
k1.fixed = self.run_settings.get('fixed', False)
k2.fixed = self.run_settings.get('fixed', False)
k1.basekern.variance = 1.0
k2.rbf.variance = 1.1
Z1 = k1.init_inducing(self.X, self.M, method=self.run_settings['Zinit'])
Z2 = self.X[np.random.permutation(len(self.X))[:self.M], :]
model_class = MeanFieldSVSumGP if run_settings["vardist"] == "mf" else FullSVSumGP
self.m = model_class(self.X, self.Y, k1, k2, GPflow.likelihoods.MultiClass(10), Z1.copy(), Z2.copy(),
num_latent=10, minibatch_size=self.run_settings.get('minibatch_size', self.M))
def setUp(self):
wconv = ckernels.WeightedConv(GPflow.kernels.RBF(4), [3, 3], [2, 2])
mcwconv = misvgp.WeightedMultiChannelConvGP(GPflow.kernels.RBF(4),
[3, 3], [2, 2])
self.kernels = [
ckernels.Conv(GPflow.kernels.RBF(4), [3, 3], [2, 2]), wconv,
ckernels.ConvRBF([3, 3], [2, 2]), mcwconv
]
def setup_model(self):
Z = None
if self.run_settings['kernel'] == "rbf":
k = GPflow.kernels.RBF(28 * 28,
ARD=self.run_settings['kernel_ard'])
Z = self.X[np.random.permutation(len(self.X))[:self.M], :]
k.lengthscales = 3.0
elif self.run_settings['kernel'] == "conv":
# k = ckern.ConvRBF([28, 28], [5, 5]) + GPflow.kernels.White(1, 1e-3)
k = ckern.Conv(
GPflow.kernels.RBF(25, ARD=self.run_settings['kernel_ard']),
[28, 28], [5, 5]) + GPflow.kernels.White(1, 1e-3)
elif self.run_settings['kernel'] == "wconv":
k = ckern.WeightedConv(
GPflow.kernels.RBF(25, ARD=self.run_settings['kernel_ard']),
[28, 28], [5, 5]) + GPflow.kernels.White(1, 1e-3)
else:
raise NotImplementedError
if Z is None:
if self.run_settings['Zinit'] == "random":
Z = np.random.rand(self.M, 9)
elif self.run_settings['Zinit'] == "patches":
subsetX = self.X[
np.random.permutation(len(self.X))[:self.M], :]
patches = k.kern_list[0].compute_patches(subsetX).reshape(
-1, k.kern_list[0].patch_len)
Z = patches[np.random.permutation(len(patches))[:self.M], :]
elif self.run_settings['Zinit'] == "patches-unique":
Z = np.zeros((1, k.kern_list[0].patch_len))
try:
from tqdm import tqdm
except ImportError:
def tqdm(x):
return x
for x in tqdm(np.split(self.X, len(self.X) // 149)):
patches = k.kern_list[0].compute_patches(x).reshape(
-1, k.kern_list[0].patch_len)
Z = np.vstack(
{tuple(row)
for row in np.vstack((Z, patches))})
Z = Z[:self.M, :]
else:
raise NotImplementedError
k.fixed = self.run_settings.get('fixed', False)
self.m = GPflow.svgp.SVGP(self.X,
self.Y,
k,
GPflow.likelihoods.Bernoulli(),
Z.copy(),
num_latent=1,
minibatch_size=self.run_settings.get(
'minibatch_size', self.M))
self.m.Z.fixed = self.run_settings.get('fixedZ', False)
def setUp(self):
self.psz = 2 # patch size
self.isz = 3 # img size
self.imgs = 4
self.k1 = ckernels.Conv(GPflow.kernels.RBF(self.psz * self.psz),
[self.isz, self.isz], [self.psz, self.psz],
colour_channels=2)
self.k2 = ckernels.ColourPatchConv(GPflow.kernels.RBF(
self.psz * self.psz * 2), [self.isz, self.isz],
[self.psz, self.psz],
colour_channels=2)
base_img = np.arange(self.imgs * self.isz * self.isz).reshape(
self.imgs, self.isz * self.isz, 1)
self.X = np.concatenate((base_img, base_img + 0.25), -1)
def setUp(self):
self.ks = [
ckernels.Conv(GPflow.kernels.RBF(4), [3, 3], [2, 2],
colour_channels=2),
ckernels.ColourPatchConv(GPflow.kernels.RBF(8), [3, 3], [2, 2],
colour_channels=2)
]
self.wks = [
ckernels.WeightedConv(GPflow.kernels.RBF(4), [3, 3], [2, 2],
colour_channels=2),
ckernels.WeightedColourPatchConv(GPflow.kernels.RBF(8), [3, 3],
[2, 2],
colour_channels=2)
]
def setup_model(self):
Z = None
if self.run_settings['kernel'] == "rbf" or self.run_settings['kernel'] == "fullgp-rbf":
k = GPflow.kernels.RBF(28 * 28, ARD=self.run_settings['kernel_ard'])
Z = self.X[np.random.permutation(len(self.X))[:self.M], :]
k.lengthscales = 3.0
elif self.run_settings['kernel'] == "conv":
# k = ckern.ConvRBF([28, 28], [3, 3]) + GPflow.kernels.White(1, 1e-3)
k = ckern.Conv(GPflow.kernels.RBF(9, ARD=self.run_settings['kernel_ard']), [28, 28],
[3, 3]) + GPflow.kernels.White(1, 1e-3)
elif self.run_settings['kernel'] == "wconv":
k = ckern.WeightedConv(GPflow.kernels.RBF(9, ARD=self.run_settings['kernel_ard']), [28, 28],
[3, 3]) + GPflow.kernels.White(1, 1e-3)
elif self.run_settings['kernel'] == "wconv-add":
basekern = (GPflow.kernels.RBF(9) +
GPflow.kernels.RBF(3, active_dims=np.s_[0:3]) +
GPflow.kernels.RBF(3, active_dims=np.s_[3:6]) +
GPflow.kernels.RBF(3, active_dims=np.s_[6:9]) +
GPflow.kernels.RBF(3, active_dims=np.s_[0:7:3]) +
GPflow.kernels.RBF(3, active_dims=np.s_[1:8:3]) +
GPflow.kernels.RBF(3, active_dims=np.s_[2:9:3]))
k = ckern.WeightedConv(basekern, [28, 28], [3, 3]) + GPflow.kernels.White(1, 1e-3)
else:
raise NotImplementedError
if Z is None:
if self.run_settings['Zinit'] == "random":
Z = np.random.rand(self.M, 9)
elif self.run_settings['Zinit'] == "patches":
subsetX = self.X[np.random.permutation(len(self.X))[:self.M], :]
patches = k.kern_list[0].compute_patches(subsetX).reshape(-1, k.kern_list[0].patch_len)
Z = patches[np.random.permutation(len(patches))[:self.M], :]
elif self.run_settings['Zinit'] == "patches-unique":
Z = np.zeros((1, k.kern_list[0].patch_len))
for x in np.split(self.X, len(self.X) // 100):
patches = k.kern_list[0].compute_patches(x).reshape(-1, k.kern_list[0].patch_len)
Z = np.vstack({tuple(row) for row in np.vstack((Z, patches))})
Z = Z[:self.M, :]
else:
raise NotImplementedError
k.fixed = self.run_settings.get('fixed', False)
if self.run_settings['kernel'] == "fullgp-rbf":
# self.m = GPflow.vgp.VGP_opper_archambeau(self.X, self.Y, k, GPflow.likelihoods.Bernoulli())
self.m = GPflow.vgp.VGP(self.X, self.Y, k, GPflow.likelihoods.Bernoulli())
else:
self.m = GPflow.svgp.SVGP(self.X, self.Y, k, GPflow.likelihoods.Bernoulli(), Z.copy(), num_latent=1,
minibatch_size=self.run_settings.get('minibatch_size', self.M))
self.m.Z.fixed = self.run_settings.get('fixedZ', False)
def setUp(self):
k = ckernels.Conv(GPflow.kernels.RBF(25), [28, 28], [5, 5])
kr = ckernels.ConvRBF([28, 28], [5, 5])
w = np.random.randn(24 * 24)
wk = ckernels.WeightedConv(GPflow.kernels.RBF(25), [28, 28], [5, 5])
wkr = ckernels.WeightedConvRBF([28, 28], [5, 5])
wk.W = w
wkr.W = w
self.testkerns = [kr, wkr]
self.refkerns = [k, wk]
self.Z = np.random.randn(5, 25)
self.X = np.random.randn(10, 28 * 28)
# set lengthscales and variances to non unit values
k.basekern.variance = 0.001
kr.basekern.variance = 0.001
k.basekern.lengthscales = 2.34
kr.basekern.lengthscales = 2.34