def gradient_ascent(r1,
r2,
theta,
gradient_magnitude,
fix_mu=False,
fix_sigma=False):
for j in range(len(theta)):
if fix_mu and j == 0: continue
if fix_sigma and j == 1: continue
prev_loss = calc_loss(r1, r2, theta)
mu, sigma, rho, p = theta
z1 = compute_pseudo_values(r1, mu, sigma, p)
z2 = compute_pseudo_values(r2, mu, sigma, p)
real_grad = calc_pseudo_log_lhd_gradient(theta, z1, z2, False, False)
gradient = numpy.zeros(len(theta))
gradient[j] = gradient_magnitude
if real_grad[j] < 0: gradient[j] = -gradient[j]
min_step = 0
max_step = find_max_step_size(theta[j], gradient[j],
(False if j in (0, 1) else True))
if max_step < 1e-12: continue
alpha = fminbound(lambda x: calc_loss(r1, r2, theta + x * gradient),
min_step, max_step)
loss = calc_loss(r1, r2, theta + alpha * gradient)
if loss < prev_loss:
theta += alpha * gradient
return theta
def EMP_with_pseudo_value_algorithm(r1,
r2,
theta_0,
N=100,
EPS=1e-4,
fix_mu=False,
fix_sigma=False):
theta = theta_0
z1 = compute_pseudo_values(r1, theta[0], theta[1], theta[3])
z2 = compute_pseudo_values(r2, theta[0], theta[1], theta[3])
max_num_EM_iter = 30
for i in range(N):
prev_theta = theta
# EM only works in the unconstrained case
if not fix_mu and not fix_sigma:
theta, new_lhd, changed_params = EM_iteration(z1,
z2,
prev_theta,
max_num_EM_iter,
fix_mu=fix_mu,
fix_sigma=fix_sigma,
eps=EPS / 10)
if fix_mu or fix_sigma or changed_params:
theta = prev_theta
theta, new_lhd = CA_iteration(z1,
z2,
prev_theta,
max_num_EM_iter,
fix_mu=fix_mu,
fix_sigma=fix_sigma,
eps=EPS / 10)
sum_param_change = numpy.abs(theta - prev_theta).sum()
prev_z1 = z1
z1 = compute_pseudo_values(r1, theta[0], theta[1], theta[3])
prev_z2 = z2
z2 = compute_pseudo_values(r2, theta[0], theta[1], theta[3])
mean_pseudo_val_change = (numpy.abs(prev_z1 - z1).mean() +
numpy.abs(prev_z2 - z2).mean())
log(
("Iter %i" % i).ljust(12),
"%.2e" % sum_param_change,
"%.2e" % mean_pseudo_val_change,
#"%.4e" % log_lhd_loss(r1, r2, theta),
theta,
level='VERBOSE')
if i > 3 and (sum_param_change < EPS and mean_pseudo_val_change < EPS):
break
return theta, log_lhd_loss(r1, r2, theta)
def find_local_maximum_CA(r1, r2, theta, fix_mu=False, fix_sigma=False):
gradient_magnitude = 1e-2
for i in range(100):
prev_loss = calc_loss(r1, r2, theta)
# coordiante ascent step
theta = coordinate_ascent(r1,
r2,
theta,
gradient_magnitude,
fix_mu=fix_mu,
fix_sigma=fix_sigma)
curr_loss = calc_loss(r1, r2, theta)
log("CA%i\t" % i,
"%.2e" % gradient_magnitude,
"%.2e" % (curr_loss - prev_loss),
"%.8f\t" % curr_loss,
"%.8f\t" % log_lhd_loss(r1, r2, theta),
theta,
level='VERBOSE')
# find the em estimate
mu, sigma, rho, p = theta
z1 = compute_pseudo_values(r1, mu, sigma, p)
z2 = compute_pseudo_values(r2, mu, sigma, p)
em_theta = EM_step(z1, z2, theta)
for j in (3, 2, 1, 0):
tmp_theta = theta.copy()
tmp_theta[j] = em_theta[j]
if calc_loss(r1, r2, tmp_theta) < curr_loss:
theta[j] = em_theta[j]
mu, sigma, rho, p = theta
z1 = compute_pseudo_values(r1, mu, sigma, p)
z2 = compute_pseudo_values(r2, mu, sigma, p)
grad = calc_pseudo_log_lhd_gradient(theta, z1, z2, False, False)
#log( "GRAD", grad )
if abs(curr_loss - prev_loss) < 1e-12:
if gradient_magnitude > 1e-6:
gradient_magnitude /= 3
else:
return (theta, curr_loss)
else:
gradient_magnitude = min(1e-2, gradient_magnitude * 10)
return theta, curr_loss
def grid_search(r1, r2):
res = []
best_theta = None
max_log_lhd = -1e100
for mu in numpy.linspace(0.1, 5, num=10):
for sigma in numpy.linspace(0.5, 3, num=10):
for rho in numpy.linspace(0.1, 0.9, num=10):
for pi in numpy.linspace(0.1, 0.9, num=10):
z1 = compute_pseudo_values(r1, mu, sigma, pi)
z2 = compute_pseudo_values(r2, mu, sigma, pi)
log_lhd = calc_gaussian_mix_log_lhd((mu, sigma, rho, pi),
z1, z2)
if log_lhd > max_log_lhd:
best_theta = ((mu, mu), (sigma, sigma), rho, pi)
max_log_lhd = log_lhd
return best_theta
def find_local_maximum_PV(r1,
r2,
theta,
N=100,
EPS=1e-6,
fix_mu=False,
fix_sigma=False):
for i in range(N):
prev_loss = calc_loss(r1, r2, theta)
curr_loss = prev_loss
# find the em estimate
mu, sigma, rho, p = theta
z1 = compute_pseudo_values(r1, mu, sigma, p)
z2 = compute_pseudo_values(r2, mu, sigma, p)
em_theta = EM_step(z1, z2, theta)
# take a step in the EM direction
for j in (3, 2, 1, 0):
tmp_theta = theta.copy()
tmp_theta[j] = em_theta[j]
new_loss = calc_loss(r1, r2, tmp_theta)
if new_loss < curr_loss:
theta[j] = em_theta[j]
curr_loss = new_loss
msg = " ".join(("CA%i\t" % i, "%.2e" % gradient_magnitude,
"%.2e" % (curr_loss - prev_loss), "%.8f\t" % curr_loss,
"%.8f\t" % log_lhd_loss(r1, r2, theta), theta))
log(msg, level='VERBOSE')
mu, sigma, rho, p = theta
z1 = compute_pseudo_values(r1, mu, sigma, p)
z2 = compute_pseudo_values(r2, mu, sigma, p)
grad = calc_gaussian_mix_log_lhd_gradient(theta, z1, z2, False, False)
if abs(curr_loss - prev_loss) < EPS:
return (theta, curr_loss)
return theta, curr_loss
def calc_local_IDR(theta, r1, r2):
"""
idr <- 1 - e.z
o <- order(idr)
idr.o <- idr[o]
idr.rank <- rank(idr.o, ties.method = "max")
top.mean <- function(index, x) {
mean(x[1:index])
}
IDR.o <- sapply(idr.rank, top.mean, idr.o)
IDR <- idr
IDR[o] <- IDR.o
"""
mu, sigma, rho, p = theta
z1 = compute_pseudo_values(r1, mu, sigma, p, EPS=1e-12)
z2 = compute_pseudo_values(r2, mu, sigma, p, EPS=1e-12)
localIDR = 1 - calc_post_membership_prbs(numpy.array(theta), z1, z2)
if idr.FILTER_PEAKS_BELOW_NOISE_MEAN:
localIDR[z1 + z2 < 0] = 1
# it doesn't make sense for the IDR values to be smaller than the
# optimization tolerance
localIDR = numpy.clip(localIDR, idr.CONVERGENCE_EPS_DEFAULT, 1)
return localIDR
def sum_grad_sq_loss(r1, r2, theta):
mu, sigma, rho, p = theta
z1 = compute_pseudo_values(r1, mu, sigma, p)
z2 = compute_pseudo_values(r2, mu, sigma, p)
grad = calc_pseudo_log_lhd_gradient(theta, z1, z2, False, False)
return (grad**2).sum()
def log_lhd_loss(r1, r2, theta):
mu, sigma, rho, p = theta
z1 = compute_pseudo_values(r1, mu, sigma, p)
z2 = compute_pseudo_values(r2, mu, sigma, p)
return -calc_gaussian_mix_log_lhd(theta, z1, z2)
