def __call__(self, emp_covs, n_samples, alpha, max_iter, tol,
iter_n, omega, prev_omega):
if iter_n == -1:
self.start_time = time.time()
self.wall_clock.append(0)
else:
self.wall_clock.append(time.time() - self.start_time)
self.score.append(group_sparse_scores(omega, n_samples, emp_covs,
alpha)[0])
self.test_score.append(group_sparse_scores(omega, n_samples,
self.test_emp_covs,
alpha)[0])
if iter_n > -1 and self.test_score[-2] > self.test_score[-1]:
if self.first_max_ind is None:
print("score decreasing")
self.first_max_ind = iter_n
def plot_benchmark1():
"""Plot various quantities obtained for varying values of alpha."""
parameters = dict(n_var=200,
n_tasks=5,
density=0.15,
tol=1e-2,
# max_iter=50,
min_samples=100,
max_samples=150)
cache_dir = get_cache_dir(parameters, output_dir=output_dir)
gt = get_ground_truth(cache_dir)
gt['precisions'] = np.dstack(gt['precisions'])
emp_covs, n_samples = empirical_covariances(gt['signals'])
n_samples /= n_samples.sum()
alpha = []
objective = []
log_likelihood = []
ll_penalized = []
sparsity = []
kl = []
true_covs = np.empty(gt['precisions'].shape)
for k in range(gt['precisions'].shape[-1]):
true_covs[..., k] = np.linalg.inv(gt['precisions'][..., k])
for out in iter_outputs(cache_dir):
alpha.append(out['alpha'])
objective.append(- out['objective'][-1])
ll, llpen = group_sparse_scores(out['precisions'],
n_samples, true_covs, out['alpha'])
log_likelihood.append(ll)
ll_penalized.append(llpen)
sparsity.append(1. * (out['precisions'][..., 0] != 0).sum()
/ out['precisions'].shape[0] ** 2)
kl.append(distance(out['precisions'], gt['precisions']))
gt["true_sparsity"] = (1. * (gt['precisions'][..., 0] != 0).sum()
/ gt['precisions'].shape[0] ** 2)
title = (("n_var: {n_var}, n_tasks: {n_tasks}, "
+ "true sparsity: {true_sparsity:.2f} "
+ "\ntol: {tol:.2e} samples: {min_samples}-{max_samples}").format(
true_sparsity=gt["true_sparsity"],
**parameters))
plot(alpha, objective, label="objective", title=title)
plot(alpha, log_likelihood, label="log-likelihood", new_figure=False)
plot(alpha, ll_penalized, label="penalized L-L", new_figure=False)
plot(alpha, sparsity, label="sparsity", title=title)
pl.hlines(gt["true_sparsity"], min(alpha), max(alpha))
plot(alpha, kl, label="distance", title=title)
pl.show()
def __call__(self, emp_covs, n_samples, alpha, max_iter, tol, n, omega,
omega_diff):
"""Probe for group_sparse_covariance that returns times and scores"""
if n == -1:
print("\n-- probe: starting '{0}' --".format(str(self.comment)))
self.start_time = time.time()
self.timings.append(0)
else:
self.timings.append(time.time() - self.start_time)
self.max_norm.append(abs(omega_diff).max())
self.l1_norm.append(abs(omega_diff).sum() / omega.size)
score, objective = group_sparse_scores(omega, n_samples, emp_covs,
alpha)
self.score.append(score)
self.objective.append(objective)
def __call__(self, emp_covs, n_samples, alpha, max_iter, tol,
iter_n, omega, prev_omega):
if iter_n == -1:
self.start_time = time.time()
self.wall_clock.append(0)
else:
self.wall_clock.append(time.time() - self.start_time)
scores = group_sparse_scores(
omega, n_samples, emp_covs, alpha,
duality_gap=not self.duality_gap is None)
self.precisions.append(omega)
if self.duality_gap is None:
log_lik, objective = scores
else:
log_lik, objective, duality_gap = scores
self.duality_gap.append(duality_gap)
self.log_lik.append(log_lik)
self.objective.append(objective)
def __call__(self, emp_covs, n_samples, alpha, max_iter, tol, n, omega,
omega_diff):
if n >= 0:
_, objective = group_sparse_scores(omega, n_samples, emp_covs,
alpha)
self.objective.append(objective)
def benchmark1():
"""Plot different quantities for varying alpha."""
# Signals
min_samples, max_samples = 100, 150 # train signals length
n_var = 50
n_tasks = 40
density = 0.1
random_state = np.random.RandomState(0)
test_samples = 4000 # number of samples for test signals
# Estimation
n_alphas = 10
max_iter = 200
tol = 1e-3
# Generate signals
signals, precisions, topology = \
testing.generate_group_sparse_gaussian_graphs(
n_subjects=n_tasks, n_features=n_var, density=density,
random_state=random_state, min_n_samples=min_samples,
max_n_samples=max_samples)
emp_covs, n_samples = empirical_covariances(signals)
# Estimate precision matrices
alpha_1, _ = compute_alpha_max(emp_covs, n_samples)
alpha_0 = 1e-2 * alpha_1
## alpha_1 = 0.067
## alpha_0 = 0.044
alphas = np.logspace(np.log10(alpha_0), np.log10(alpha_1), n_alphas)[::-1]
parameters = joblib.Parallel(n_jobs=7, verbose=1)(
joblib.delayed(group_sparse_covariance)(emp_covs, n_samples, alpha,
max_iter=max_iter, tol=tol)
for alpha in alphas)
# Compute scores
test_signals = testing.generate_signals_from_precisions(
precisions, min_n_samples=test_samples, max_n_samples=test_samples + 1,
random_state=random_state)
test_emp_covs, _ = empirical_covariances(test_signals)
del test_signals
for params in parameters:
params["ll_score"], params["pen_score"] = group_sparse_scores(
params["precisions"], n_samples, test_emp_covs, params["alpha"])
# Plot graphs
alpha, ll_score, pen_score = get_series(
parameters, ("alpha", "ll_score", "pen_score"))
non_zero = [(p["precisions"][..., 0] != 0).sum() for p in parameters]
pl.figure()
pl.semilogx(alpha, ll_score, "-+", label="log-likelihood")
pl.semilogx(alpha, pen_score, "-+", label="penalized LL")
pl.xlabel("alpha")
pl.ylabel("score")
pl.grid()
pl.figure()
pl.semilogx(alpha, non_zero, "-+")
pl.xlabel("alpha")
pl.ylabel("non_zero")
pl.grid()
pl.figure()
pl.loglog(alpha, non_zero, "-+")
pl.xlabel("alpha")
pl.ylabel("non_zero")
pl.grid()
pl.figure()
pl.imshow(topology, interpolation="nearest")
pl.title("true topology")
## precisions = get_series(parameters, ("precisions", ))
## for prec, alpha in zip(precisions, alpha):
## pl.figure()
## pl.imshow(prec[..., 0] != 0, interpolation="nearest")
## pl.title(alpha)
pl.show()
def __call__(self, emp_covs, n_samples, alpha, max_iter, tol, n, omega,
omega_diff):
if n >= 0:
_, objective = group_sparse_scores(omega, n_samples, emp_covs,
alpha)
self.objective.append(objective)
