def test_mogsm(self):
mcgsm = MCGSM(
dim_in=0,
dim_out=3,
num_components=2,
num_scales=2,
num_features=0)
p0 = 0.3
p1 = 0.7
N = 20000
m0 = array([[2], [0], [0]])
m1 = array([[0], [2], [1]])
C0 = cov(randn(mcgsm.dim_out, mcgsm.dim_out**2))
C1 = cov(randn(mcgsm.dim_out, mcgsm.dim_out**2))
input = zeros([0, N])
output = hstack([
dot(cholesky(C0), randn(mcgsm.dim_out, round(p0 * N))) + m0,
dot(cholesky(C1), randn(mcgsm.dim_out, round(p1 * N))) + m1]) * (rand(1, N) + 0.5)
mcgsm.train(input, output, parameters={
'verbosity': 0,
'max_iter': 10,
'train_means': True})
mogsm = MoGSM(3, 2, 2)
# translate parameters from MCGSM to MoGSM
mogsm.priors = sum(exp(mcgsm.priors), 1) / sum(exp(mcgsm.priors))
for k in range(mogsm.num_components):
mogsm[k].mean = mcgsm.means[:, k]
mogsm[k].covariance = inv(dot(mcgsm.cholesky_factors[k], mcgsm.cholesky_factors[k].T))
mogsm[k].scales = exp(mcgsm.scales[k, :])
mogsm[k].priors = exp(mcgsm.priors[k, :]) / sum(exp(mcgsm.priors[k, :]))
self.assertAlmostEqual(mcgsm.evaluate(input, output), mogsm.evaluate(output), 5)
mogsm_samples = mogsm.sample(N)
mcgsm_samples = mcgsm.sample(input)
# generated samples should have the same distribution
for i in range(mogsm.dim):
self.assertTrue(ks_2samp(mogsm_samples[i], mcgsm_samples[0]) > 0.0001)
self.assertTrue(ks_2samp(mogsm_samples[i], mcgsm_samples[1]) > 0.0001)
self.assertTrue(ks_2samp(mogsm_samples[i], mcgsm_samples[2]) > 0.0001)
posterior = mcgsm.posterior(input, mcgsm_samples)
# average posterior should correspond to prior
for k in range(mogsm.num_components):
self.assertLess(abs(1 - mean(posterior[k]) / mogsm.priors[k]), 0.1)
def test_basics(self):
dim_in = 10
dim_out = 3
num_components = 7
num_scales = 5
num_features = 50
num_samples = 100
# create model
mcgsm = MCGSM(dim_in, dim_out, num_components, num_scales,
num_features)
# generate output
input = randn(dim_in, num_samples)
output = mcgsm.sample(input)
loglik = mcgsm.loglikelihood(input, output)
post = mcgsm.posterior(input, output)
samples = mcgsm.sample_posterior(input, output)
# check hyperparameters
self.assertEqual(mcgsm.dim_in, dim_in)
self.assertEqual(mcgsm.dim_out, dim_out)
self.assertEqual(mcgsm.num_components, num_components)
self.assertEqual(mcgsm.num_scales, num_scales)
self.assertEqual(mcgsm.num_features, num_features)
# check parameters
self.assertEqual(mcgsm.priors.shape[0], num_components)
self.assertEqual(mcgsm.priors.shape[1], num_scales)
self.assertEqual(mcgsm.scales.shape[0], num_components)
self.assertEqual(mcgsm.scales.shape[1], num_scales)
self.assertEqual(mcgsm.weights.shape[0], num_components)
self.assertEqual(mcgsm.weights.shape[1], num_features)
self.assertEqual(mcgsm.features.shape[0], dim_in)
self.assertEqual(mcgsm.features.shape[1], num_features)
self.assertEqual(len(mcgsm.cholesky_factors), num_components)
self.assertEqual(len(mcgsm.predictors), num_components)
self.assertEqual(mcgsm.cholesky_factors[0].shape[0], dim_out)
self.assertEqual(mcgsm.cholesky_factors[0].shape[1], dim_out)
self.assertEqual(mcgsm.predictors[0].shape[0], dim_out)
self.assertEqual(mcgsm.predictors[0].shape[1], dim_in)
self.assertEqual(mcgsm.linear_features.shape[0], num_components)
self.assertEqual(mcgsm.linear_features.shape[1], dim_in)
self.assertEqual(mcgsm.means.shape[0], dim_out)
self.assertEqual(mcgsm.means.shape[1], num_components)
# check dimensionality of output
self.assertEqual(output.shape[0], dim_out)
self.assertEqual(output.shape[1], num_samples)
self.assertEqual(loglik.shape[0], 1)
self.assertEqual(loglik.shape[1], num_samples)
self.assertEqual(post.shape[0], num_components)
self.assertEqual(post.shape[1], num_samples)
self.assertLess(max(samples), mcgsm.num_components)
self.assertGreaterEqual(min(samples), 0)
self.assertEqual(samples.shape[0], 1)
self.assertEqual(samples.shape[1], num_samples)
def test_basics(self):
dim_in = 10
dim_out = 3
num_components = 7
num_scales = 5
num_features = 50
num_samples = 100
# create model
mcgsm = MCGSM(dim_in, dim_out, num_components, num_scales, num_features)
# generate output
input = randn(dim_in, num_samples)
output = mcgsm.sample(input)
loglik = mcgsm.loglikelihood(input, output)
post = mcgsm.posterior(input, output)
samples = mcgsm.sample_posterior(input, output)
# check hyperparameters
self.assertEqual(mcgsm.dim_in, dim_in)
self.assertEqual(mcgsm.dim_out, dim_out)
self.assertEqual(mcgsm.num_components, num_components)
self.assertEqual(mcgsm.num_scales, num_scales)
self.assertEqual(mcgsm.num_features, num_features)
# check parameters
self.assertEqual(mcgsm.priors.shape[0], num_components)
self.assertEqual(mcgsm.priors.shape[1], num_scales)
self.assertEqual(mcgsm.scales.shape[0], num_components)
self.assertEqual(mcgsm.scales.shape[1], num_scales)
self.assertEqual(mcgsm.weights.shape[0], num_components)
self.assertEqual(mcgsm.weights.shape[1], num_features)
self.assertEqual(mcgsm.features.shape[0], dim_in)
self.assertEqual(mcgsm.features.shape[1], num_features)
self.assertEqual(len(mcgsm.cholesky_factors), num_components)
self.assertEqual(len(mcgsm.predictors), num_components)
self.assertEqual(mcgsm.cholesky_factors[0].shape[0], dim_out)
self.assertEqual(mcgsm.cholesky_factors[0].shape[1], dim_out)
self.assertEqual(mcgsm.predictors[0].shape[0], dim_out)
self.assertEqual(mcgsm.predictors[0].shape[1], dim_in)
self.assertEqual(mcgsm.linear_features.shape[0], num_components)
self.assertEqual(mcgsm.linear_features.shape[1], dim_in)
self.assertEqual(mcgsm.means.shape[0], dim_out)
self.assertEqual(mcgsm.means.shape[1], num_components)
# check dimensionality of output
self.assertEqual(output.shape[0], dim_out)
self.assertEqual(output.shape[1], num_samples)
self.assertEqual(loglik.shape[0], 1)
self.assertEqual(loglik.shape[1], num_samples)
self.assertEqual(post.shape[0], num_components)
self.assertEqual(post.shape[1], num_samples)
self.assertLess(max(samples), mcgsm.num_components)
self.assertGreaterEqual(min(samples), 0)
self.assertEqual(samples.shape[0], 1)
self.assertEqual(samples.shape[1], num_samples)
def test_mogsm(self):
mcgsm = MCGSM(dim_in=0,
dim_out=3,
num_components=2,
num_scales=2,
num_features=0)
p0 = 0.3
p1 = 0.7
N = 20000
m0 = array([[2], [0], [0]])
m1 = array([[0], [2], [1]])
C0 = cov(randn(mcgsm.dim_out, mcgsm.dim_out**2))
C1 = cov(randn(mcgsm.dim_out, mcgsm.dim_out**2))
input = zeros([0, N])
output = hstack([
dot(cholesky(C0), randn(mcgsm.dim_out, round(p0 * N))) + m0,
dot(cholesky(C1), randn(mcgsm.dim_out, round(p1 * N))) + m1
]) * (rand(1, N) + 0.5)
mcgsm.train(input,
output,
parameters={
'verbosity': 0,
'max_iter': 10,
'train_means': True
})
mogsm = MoGSM(3, 2, 2)
# translate parameters from MCGSM to MoGSM
mogsm.priors = sum(exp(mcgsm.priors), 1) / sum(exp(mcgsm.priors))
for k in range(mogsm.num_components):
mogsm[k].mean = mcgsm.means[:, k]
mogsm[k].covariance = inv(
dot(mcgsm.cholesky_factors[k], mcgsm.cholesky_factors[k].T))
mogsm[k].scales = exp(mcgsm.scales[k, :])
mogsm[k].priors = exp(mcgsm.priors[k, :]) / sum(
exp(mcgsm.priors[k, :]))
self.assertAlmostEqual(mcgsm.evaluate(input, output),
mogsm.evaluate(output), 5)
mogsm_samples = mogsm.sample(N)
mcgsm_samples = mcgsm.sample(input)
# generated samples should have the same distribution
for i in range(mogsm.dim):
self.assertTrue(
ks_2samp(mogsm_samples[i], mcgsm_samples[0]) > 0.0001)
self.assertTrue(
ks_2samp(mogsm_samples[i], mcgsm_samples[1]) > 0.0001)
self.assertTrue(
ks_2samp(mogsm_samples[i], mcgsm_samples[2]) > 0.0001)
posterior = mcgsm.posterior(input, mcgsm_samples)
# average posterior should correspond to prior
for k in range(mogsm.num_components):
self.assertLess(abs(1 - mean(posterior[k]) / mogsm.priors[k]), 0.1)
model = MCGSM(
dim_in=args.dim_in,
dim_out=args.dim_out,
num_components=12,
num_features=40,
num_scales=6)
###
print 'model.loglikelihood'
t = time()
for r in range(args.repetitions):
model.loglikelihood(*data)
print '{0:12.8f} seconds'.format((time() - t) / float(args.repetitions))
print
###
print 'model._check_performance'
for batch_size in [1000, 2000, 5000]:
t = model._check_performance(*data, repetitions=args.repetitions, parameters={'batch_size': batch_size})
print '{0:12.8f} seconds ({1})'.format(t, batch_size)
print
###
print 'model.posterior'
t = time()
for r in range(args.repetitions):
model.posterior(*data)
print '{0:12.8f} seconds'.format((time() - t) / float(args.repetitions))
print
model = MCGSM(dim_in=args.dim_in,
dim_out=args.dim_out,
num_components=12,
num_features=40,
num_scales=6)
###
print 'model.loglikelihood'
t = time()
for r in range(args.repetitions):
model.loglikelihood(*data)
print '{0:12.8f} seconds'.format((time() - t) / float(args.repetitions))
print
###
print 'model._check_performance'
for batch_size in [1000, 2000, 5000]:
t = model._check_performance(*data,
repetitions=args.repetitions,
parameters={'batch_size': batch_size})
print '{0:12.8f} seconds ({1})'.format(t, batch_size)
print
###
print 'model.posterior'
t = time()
for r in range(args.repetitions):
model.posterior(*data)
print '{0:12.8f} seconds'.format((time() - t) / float(args.repetitions))
print
