class GFunction(object):
def __init__(self, distribution, n=200, kernel=GaussianKernel(3), nu2=0.1, \
gamma=0.1, ell=15, nXs=100, nYs=100):
self.kernel = kernel
self.distribution = distribution
self.nu2 = nu2
self.gamma = gamma
self.ell = ell
# fix some samples
self.Z = self.distribution.sample(n).samples
# evaluate and center kernel and scale
self.K = self.kernel.kernel(self.Z, None)
self.K = Kernel.center_kernel_matrix(self.K)
# sample beta
self.rkhs_gaussian = Gaussian(mu=zeros(len(self.Z)), Sigma=self.K, is_cholesky=False, \
ell=self.ell)
self.beta = self.rkhs_gaussian.sample().samples
# plotting resolution
[(xmin, xmax), (ymin, ymax)] = self.distribution.get_plotting_bounds()
self.Xs = linspace(xmin, xmax, nXs)
self.Ys = linspace(ymin, ymax, nYs)
def resample_beta(self):
self.beta = self.rkhs_gaussian.sample().samples
def compute(self, x, y, Z, beta):
"""
Given two points x and y, a set of samples Z, and a vector beta,
and a kernel function, this computes the g function
g(x,beta,Z)=||k(x,.)-f|| for f=k(.,y)+sum_i beta_i*k(.,z_i)
=k(x,x) -2k(x,y) -2sum_i beta_i*k(x,z_i) +C
Constant C is not computed
"""
first = self.kernel.kernel(x, x)
second = -2 * self.kernel.kernel(x, y)
third = -2 * self.kernel.kernel(x, Z).dot(beta.T)
return first + second + third
def compute_gradient(self, x, y, Z, beta):
"""
Given two points x and y, a set of samples Z, and a vector beta,
and a kernel gradient, this computes the g function's gradient
\nabla_x g(x,beta,Z)=\nabla_x k(x,x) -2k(x,y) -2sum_i beta_i*k(x,z_i)
"""
x_2d = reshape(x, (1, len(x)))
first = self.kernel.gradient(x, x_2d)
second = -2 * self.kernel.gradient(x, y)
# compute sum_i beta_i \nabla_x k(x,z_i) and beta is a row vector
gradients = self.kernel.gradient(x, Z)
third = -2 * beta.dot(gradients)
return first + second + third
def plot(self, y=array([[-2, -2]]), gradient_scale=None, plot_data=False):
# where to evaluate G?
G = zeros((len(self.Ys), len(self.Xs)))
# for plotting the gradient field, each U and V are one dimension of gradient
if gradient_scale is not None:
GXs2 = linspace(self.Xs.min(), self.Xs.max(), 30)
GYs2 = linspace(self.Ys.min(), self.Ys.max(), 20)
X, Y = meshgrid(GXs2, GYs2)
U = zeros(shape(X))
V = zeros(shape(Y))
# evaluate g at a set of points in Xs and Ys
for i in range(len(self.Xs)):
# print i, "/", len(self.Xs)
for j in range(len(self.Ys)):
x_2d = array([[self.Xs[i], self.Ys[j]]])
y_2d = reshape(y, (1, len(y)))
G[j, i] = self.compute(x_2d, y_2d, self.Z, self.beta)
# gradient at lower resolution
if gradient_scale is not None:
for i in range(len(GXs2)):
# print i, "/", len(GXs2)
for j in range(len(GYs2)):
x_1d = array([GXs2[i], GYs2[j]])
y_2d = reshape(y, (1, len(y)))
G_grad = self.compute_gradient(x_1d, y_2d, self.Z, self.beta)
U[j, i] = -G_grad[0, 0]
V[j, i] = -G_grad[0, 1]
# plot g and Z points and y
y_2d = reshape(y, (1, len(y)))
Visualise.plot_array(self.Xs, self.Ys, G)
if gradient_scale is not None:
hold(True)
quiver(X, Y, U, V, color='y', scale=gradient_scale)
hold(False)
if plot_data:
hold(True)
Visualise.plot_data(self.Z, y_2d)
hold(False)
def plot_proposal(self, ys):
# evaluate density itself
Visualise.visualise_distribution(self.distribution, Z=self.Z, Xs=self.Xs, Ys=self.Ys)
# precompute constants of proposal
mcmc_hammer = Kameleon(self.distribution, self.kernel, self.Z, \
self.nu2, self.gamma)
# plot proposal around each y
for y in ys:
mu, L_R = mcmc_hammer.compute_constants(y)
gaussian = Gaussian(mu, L_R, is_cholesky=True)
hold(True)
Visualise.contour_plot_density(gaussian)
hold(False)
draw()
def main():
numTrials = 500
n=200
Sigma1 = eye(2)
Sigma1[0, 0] = 30.0
Sigma1[1, 1] = 1.0
theta = - pi / 4
U = MatrixTools.rotation_matrix(theta)
Sigma1 = U.T.dot(Sigma1).dot(U)
print Sigma1
gaussian1 = Gaussian(Sigma=Sigma1)
gaussian2 = Gaussian(mu=array([1., 0.]), Sigma=Sigma1)
oracle_samples1 = gaussian1.sample(n=n).samples
oracle_samples2 = gaussian2.sample(n=n).samples
print 'mean1:', mean(oracle_samples1,0)
print 'mean2:', mean(oracle_samples2,0)
plot(oracle_samples1[:,0],oracle_samples1[:,1],'b*')
plot(oracle_samples2[:,0],oracle_samples2[:,1],'r*')
show()
distribution1 = GaussianFullConditionals(gaussian1, list(gaussian1.mu))
distribution2 = GaussianFullConditionals(gaussian2, list(gaussian2.mu))
H0_samples = zeros(numTrials)
HA_samples = zeros(numTrials)
mcmc_sampler1 = Gibbs(distribution1)
mcmc_sampler2 = Gibbs(distribution2)
burnin = 9000
thin = 5
start = zeros(2)
mcmc_params = MCMCParams(start=start, num_iterations=burnin+thin*n, burnin=burnin)
sigma = GaussianKernel.get_sigma_median_heuristic(concatenate((oracle_samples1,oracle_samples2),axis=0))
print 'using bandwidth: ', sigma
kernel = GaussianKernel(sigma=sigma)
for ii in arange(numTrials):
start =time.time()
print 'trial:', ii
oracle_samples1 = gaussian1.sample(n=n).samples
oracle_samples1a = gaussian1.sample(n=n).samples
oracle_samples2 = gaussian2.sample(n=n).samples
# chain1 = MCMCChain(mcmc_sampler1, mcmc_params)
# chain1.run()
# gibbs_samples1 = chain1.get_samples_after_burnin()
# gibbs_samples1 = gibbs_samples1[thin*arange(n)]
#
# chain1a = MCMCChain(mcmc_sampler1, mcmc_params)
# chain1a.run()
# gibbs_samples1a = chain1a.get_samples_after_burnin()
# gibbs_samples1a = gibbs_samples1a[thin*arange(n)]
#
# chain2 = MCMCChain(mcmc_sampler2, mcmc_params)
# chain2.run()
# gibbs_samples2 = chain2.get_samples_after_burnin()
# gibbs_samples2 = gibbs_samples2[thin*arange(n)]
# H0_samples[ii]=kernel.estimateMMD(gibbs_samples1,gibbs_samples1a)
# HA_samples[ii]=kernel.estimateMMD(gibbs_samples1,gibbs_samples2)
#
H0_samples[ii]=kernel.estimateMMD(oracle_samples1,oracle_samples1a)
HA_samples[ii]=kernel.estimateMMD(oracle_samples1,oracle_samples2)
end=time.time()
print 'time elapsed: ', end-start
f = open("/home/dino/git/mmdIIDTrueSamples.dat", "w")
dump(H0_samples, f)
dump(HA_samples, f)
dump(gaussian1, f)
dump(gaussian2, f)
f.close()
return None
def main():
numTrials = 500
n = 200
Sigma1 = eye(2)
Sigma1[0, 0] = 30.0
Sigma1[1, 1] = 1.0
theta = -pi / 4
U = MatrixTools.rotation_matrix(theta)
Sigma1 = U.T.dot(Sigma1).dot(U)
print Sigma1
gaussian1 = Gaussian(Sigma=Sigma1)
gaussian2 = Gaussian(mu=array([1., 0.]), Sigma=Sigma1)
oracle_samples1 = gaussian1.sample(n=n).samples
oracle_samples2 = gaussian2.sample(n=n).samples
print 'mean1:', mean(oracle_samples1, 0)
print 'mean2:', mean(oracle_samples2, 0)
plot(oracle_samples1[:, 0], oracle_samples1[:, 1], 'b*')
plot(oracle_samples2[:, 0], oracle_samples2[:, 1], 'r*')
show()
distribution1 = GaussianFullConditionals(gaussian1, list(gaussian1.mu))
distribution2 = GaussianFullConditionals(gaussian2, list(gaussian2.mu))
H0_samples = zeros(numTrials)
HA_samples = zeros(numTrials)
mcmc_sampler1 = Gibbs(distribution1)
mcmc_sampler2 = Gibbs(distribution2)
burnin = 9000
thin = 5
start = zeros(2)
mcmc_params = MCMCParams(start=start,
num_iterations=burnin + thin * n,
burnin=burnin)
sigma = GaussianKernel.get_sigma_median_heuristic(
concatenate((oracle_samples1, oracle_samples2), axis=0))
print 'using bandwidth: ', sigma
kernel = GaussianKernel(sigma=sigma)
for ii in arange(numTrials):
start = time.time()
print 'trial:', ii
oracle_samples1 = gaussian1.sample(n=n).samples
oracle_samples1a = gaussian1.sample(n=n).samples
oracle_samples2 = gaussian2.sample(n=n).samples
# chain1 = MCMCChain(mcmc_sampler1, mcmc_params)
# chain1.run()
# gibbs_samples1 = chain1.get_samples_after_burnin()
# gibbs_samples1 = gibbs_samples1[thin*arange(n)]
#
# chain1a = MCMCChain(mcmc_sampler1, mcmc_params)
# chain1a.run()
# gibbs_samples1a = chain1a.get_samples_after_burnin()
# gibbs_samples1a = gibbs_samples1a[thin*arange(n)]
#
# chain2 = MCMCChain(mcmc_sampler2, mcmc_params)
# chain2.run()
# gibbs_samples2 = chain2.get_samples_after_burnin()
# gibbs_samples2 = gibbs_samples2[thin*arange(n)]
# H0_samples[ii]=kernel.estimateMMD(gibbs_samples1,gibbs_samples1a)
# HA_samples[ii]=kernel.estimateMMD(gibbs_samples1,gibbs_samples2)
#
H0_samples[ii] = kernel.estimateMMD(oracle_samples1, oracle_samples1a)
HA_samples[ii] = kernel.estimateMMD(oracle_samples1, oracle_samples2)
end = time.time()
print 'time elapsed: ', end - start
f = open("/home/dino/git/mmdIIDTrueSamples.dat", "w")
dump(H0_samples, f)
dump(HA_samples, f)
dump(gaussian1, f)
dump(gaussian2, f)
f.close()
return None
