def select_sigma_lambda_cma(Z,
num_folds=5,
num_repetitions=1,
sigma0=1.1,
lmbda0=1.1,
cma_opts={},
disp=False):
import cma
start = np.log2(np.array([sigma0, lmbda0]))
es = cma.CMAEvolutionStrategy(start, 1., cma_opts)
while not es.stop():
if disp:
es.disp()
solutions = es.ask()
values = np.zeros(len(solutions))
for i, (log2_sigma, log2_lmbda) in enumerate(solutions):
sigma = 2**log2_sigma
lmbda = 2**log2_lmbda
K = gaussian_kernel(Z, sigma=sigma)
folds = xvalidate(Z, num_folds, sigma, lmbda, K)
values[i] = np.mean(folds)
logger.info("particle %d/%d, sigma: %.2f, lambda: %.2f, J=%.4f" % \
(i + 1, len(solutions), sigma, lmbda, values[i]))
es.tell(solutions, values)
return es
def select_sigma_grid(Z,
num_folds=5,
num_repetitions=1,
log2_sigma_min=-3,
log2_sigma_max=10,
resolution_sigma=25,
lmbda=1.,
plot_surface=False):
sigmas = 2**np.linspace(log2_sigma_min, log2_sigma_max, resolution_sigma)
Js = np.zeros(len(sigmas))
for i, sigma in enumerate(sigmas):
K = gaussian_kernel(Z, sigma=sigma)
folds = xvalidate(Z, num_folds, sigma, lmbda, K)
Js[i] = np.mean(folds)
logger.info("sigma trial %d/%d, sigma: %.2f, lambda: %.2f, J=%.2f" % \
(i + 1, len(sigmas), sigma, lmbda, Js[i]))
if plot_surface:
plt.figure()
plt.plot(np.log2(sigmas), Js)
best_sigma_idx = Js.argmin()
best_sigma = sigmas[best_sigma_idx]
logger.info("Best sigma: %.2f with J=%.2f" %
(best_sigma, Js[best_sigma_idx]))
return best_sigma
def update_plot(val=None):
sigma = 2**s_sigma.val
lmbda = 2**s_lmbda.val
K = gaussian_kernel(Z, sigma=sigma)
b = _compute_b_sym(Z, K, sigma)
C = _compute_C_sym(Z, K, sigma)
a = score_matching_sym(Z, sigma, lmbda, K, b, C)
J = _objective_sym(Z, sigma, lmbda, a, K, b, C)
J_xval = np.mean(xvalidate(Z, 5, sigma, lmbda, K, num_repetitions=3))
print(a[:5])
kernel = lambda X, Y=None: gaussian_kernel(X, Y, sigma=sigma)
kernel_grad = lambda x, X=None: gaussian_kernel_grad(x, X, sigma)
logq_est = lambda x: log_pdf_estimate(x, a, Z, kernel)
dlogq_est = lambda x: log_pdf_estimate_grad(x, a, Z, kernel_grad)
description = "N=%d, sigma: %.2f, lambda: %.2f, J(a)=%.2f, XJ(a)=%.2f" % \
(N, sigma, lmbda, J, J_xval)
if plot_pdf:
D = evaluate_density_grid(Xs, Ys, logq_est)
description = "log-pdf: " + description
else:
D = evaluate_density_grad_grid(Xs, Ys, dlogq_est)
description = "norm-grad-log-pdf: " + description
ax.clear()
ax.plot(Z[:, 0], Z[:, 1], 'bx')
plot_array(Xs, Ys, D, ax, plot_contour=True)
ax.set_title(description)
fig.canvas.draw_idle()
def optimise_sigma_surface(val):
print("sigma")
log2_lmbda = s_lmbda.val
lmbda = 2**log2_lmbda
log2_sigmas = np.linspace(s_sigma.valmin, s_sigma.valmax)
Js = np.zeros(len(log2_sigmas))
for i, log2_sigma in enumerate(log2_sigmas):
sigma = 2**log2_sigma
K = gaussian_kernel(Z, sigma=sigma)
Js[i] = np.mean(xvalidate(Z, 5, sigma, lmbda, K, num_repetitions=3))
log2_sigma_min = log2_sigmas[Js.argmin()]
log_Js = np.log(Js - (Js.min() if Js.min() < 0 else 0) + 1)
# update slider
s_sigma.set_val(log2_sigma_min)
update_plot()
plt.figure()
plt.plot(log2_sigmas, log_Js)
plt.plot([log2_sigma_min, log2_sigma_min],
[log_Js.min(), log_Js.max()], 'r')
plt.title(
r"$\sigma$ surface for $\log_2 \lambda=%.2f$, best value of $J(\alpha)=%.2f$ at $\log_2 \sigma=%.2f$"
% (log2_lmbda, Js.min(), log2_sigma_min))
plt.show()
def plot_lmbda_surface(val):
print("lambda")
log2_sigma = s_sigma.val
sigma = 2**log2_sigma
K = gaussian_kernel(Z, sigma=sigma)
log2_lambdas = np.linspace(s_lmbda.valmin, s_lmbda.valmax)
Js = np.array([
np.mean(xvalidate(Z, 5, sigma, 2**log2_lmbda, K, num_repetitions=3))
for log2_lmbda in log2_lambdas
])
log2_lambda_min = log2_lambdas[Js.argmin()]
log_Js = np.log(Js - (Js.min() if Js.min() < 0 else 0) + 1)
# update slider
s_lmbda.set_val(log2_lambda_min)
update_plot()
plt.figure()
plt.plot(log2_lambdas, log_Js)
plt.plot([log2_lambda_min, log2_lambda_min],
[log_Js.min(), log_Js.max()], 'r')
plt.title(
r"$\lambda$ surface for $\log_2 \sigma=%.2f$, best value of $J(\alpha)=%.2f$ at $\log_2 \lambda=%.2f$"
% (log2_sigma, Js.min(), log2_lambda_min))
plt.show()
def fun(sigma_lmbda, num_repetitions=1):
log2_sigma = sigma_lmbda[0]
log2_lmbda = sigma_lmbda[1]
sigma = 2**log2_sigma
lmbda = 2**log2_lmbda
K = gaussian_kernel(Z, sigma=sigma)
folds = [
xvalidate(Z, num_folds, sigma, lmbda, K)
for _ in range(num_repetitions)
]
J = np.mean(folds)
J_std = np.std(folds)
print("fun: log2_sigma=%.2f, log_lmbda=%.2f, J(a)=%.2f" %
(log2_sigma, log2_lmbda, J))
return J, J_std
dlogq = lambda x: log_gaussian_pdf(x, Sigma=L, is_cholesky=True, compute_grad=True)
logq = lambda x: log_gaussian_pdf(x, Sigma=L, is_cholesky=True, compute_grad=False)
# estimate density in rkhs
N = 200
mu = np.zeros(D)
Z = sample_gaussian(N, mu, Sigma=L, is_cholesky=True)
lmbda = 1.
sigma = select_sigma_grid(Z, lmbda=lmbda, plot_surface=False)
K = gaussian_kernel(Z, sigma=sigma)
b = _compute_b_sym(Z, K, sigma)
C = _compute_C_sym(Z, K, sigma)
a = score_matching_sym(Z, sigma, lmbda, K, b, C)
J = _objective_sym(Z, sigma, lmbda, a, K, b, C)
J_xval = np.mean(xvalidate(Z, 5, sigma, lmbda, K))
print("N=%d, sigma: %.2f, lambda: %.2f, J(a)=%.2f, XJ(a)=%.2f" % \
(N, sigma, lmbda, J, J_xval))
kernel = lambda X, Y = None: gaussian_kernel(X, Y, sigma=sigma)
kernel_grad = lambda x, X = None: gaussian_kernel_grad(x, X, sigma)
logq_est = lambda x: log_pdf_estimate(x, a, Z, kernel)
dlogq_est = lambda x: log_pdf_estimate_grad(x, a, Z, kernel_grad)
# momentum
Sigma_p = np.eye(D)
L_p = np.linalg.cholesky(Sigma_p)
logp = lambda x: log_gaussian_pdf(x, Sigma=L_p, compute_grad=False, is_cholesky=True)
dlogp = lambda x: log_gaussian_pdf(x, Sigma=L_p, compute_grad=True, is_cholesky=True)
p_sample = lambda: sample_gaussian(N=1, mu=np.zeros(D), Sigma=L_p, is_cholesky=True)[0]
from kmc.score_matching.kernel.kernels import gaussian_kernel
from kmc.score_matching.lite.gaussian_rkhs import xvalidate
from kmc.score_matching.lite.gaussian_rkhs_xvalidation import select_sigma_lambda_cma
import numpy as np
if __name__ == "__main__":
np.random.seed(0)
N = 200
Z = np.random.randn(N, 2)
# print np.sum(Z) * np.std(Z) * np.sum(Z**2) * np.std(Z**2)
cma_opts = {
'tolfun': 1e-2,
'maxiter': 20,
'verb_disp': 1,
'bounds': [-3, 5]
}
es = select_sigma_lambda_cma(Z, cma_opts=cma_opts, disp=True)
log2_sigma = es.best.get()[0][0]
log2_lmbda = es.best.get()[0][1]
sigma = 2**log2_sigma
lmbda = 2**log2_lmbda
K = gaussian_kernel(Z, sigma=sigma)
print(log2_sigma, log2_lmbda, np.mean(xvalidate(Z, 5, sigma, lmbda, K)))
