def pseudo_BIC_search(Y,
J_range,
lambda_range,
mu_range,
tau_range,
theta_bound=1.0,
tvw=None,
initB='pca',
maxK=200,
maxN=100,
eps=1e-3,
eps_gap='auto',
step=1.0,
eps_jumps=1e-3,
callback=None):
L, S = Y.shape
J_range = sorted(J_range)
mu_range = sorted(mu_range)
lambda_range = sorted(lambda_range)
tau_range = sorted(tau_range)
# Parameters dimensions
m, l, t = len(mu_range), len(lambda_range), len(tau_range)
# CGHDL params
params = {
'theta_bound': theta_bound,
'tvw': tvw,
'maxK': maxK,
'maxN': maxN,
'eps': eps,
'eps_gap': eps_gap,
'step': step
}
for J in J_range:
# For each new J value we start from following B0 and Theta0
B0 = utils.initB(Y, J)
#Theta0 = np.ones((J, S)) * theta_bound
Theta0 = np.zeros((J, S)) # for comparison with original FLLat
# Evaluation
for j, i, k in it.product(range(l), range(m), range(t)):
time = alg.minimize(Y,
J,
lambda_=lambda_range[j],
mu=mu_range[i],
tau=tau_range[k],
initB=B0,
initTheta=Theta0,
**params)
# Callback execution
if not callback is None:
callback(time, J, lambda_range[j], mu_range[i], tau_range[k])
def minimize(Y,
J,
lambda_,
mu,
tau,
theta_bound=1.0,
tvw=None,
initB='pca',
initTheta=None,
maxK=200,
maxN=100,
eps=1e-3,
eps_gap='auto',
step=1.0):
L, S = Y.shape
#### B Initialization
try:
assert initB.shape == (L, J)
B0 = initB.copy()
except AttributeError:
assert initB in ['pca', 'rand']
B0 = utils.initB(Y, J, initB)
#### Theta Initialization
# Theta0 = np.zeros((J, S)) # <- default
# Parameters normalization
#lambda_ *= (S/float(J)) # l, j -- /S
#mu *= (S/float(J)) # l, j -- /S
lambda_ *= 2.0 * (S / float(J)) # l, j -- /S
mu *= 2.0 * (S / float(J)) # l, j -- /S
s_time = time.time()
result = FLLat(
Y,
J=J,
B=B0,
lam1=lambda_,
lam2=mu,
thresh=eps, # 1e-4 (default)
maxiter=maxK, # 100 (default)
maxiter_B=maxN, # 1 ( // )
maxiter_T=maxN) # 1 ( // )
return time.time() - s_time
def minimize(Y,
J,
lambda_,
mu,
initB='pca',
initTheta=None,
maxK=200,
maxN=100,
eps=1e-3,
callback=None):
L, S = Y.shape
#### B Initialization
try:
assert initB.shape == (L, J)
B0 = initB.copy()
except AttributeError:
assert initB in ['pca', 'rand']
B0 = utils.initB(Y, J, initB)
#### Theta Initialization
try:
assert initTheta.shape == (J, S)
Theta0 = initTheta.copy()
except AttributeError:
#Theta0 = np.ones((J, S)) * theta_bound
Theta0 = np.zeros((J, S)) # for comparison with original FLLat
#### Precision
p = 1. # How to justify such a choice?
eta = 1. / (S * J)
zeta = 1. / (L * J)
# Parameters normalization
lambda_ *= (S / float(J)) # l, j -- /S
mu *= (S / float(J)) # l, j -- /S
#### Starting Duality Gap for PHI (with Vi=0, B fixed and Gamma=Theta0)
C_phi = proxf.c_phi(Y, Theta0, B0, eta)
#### Starting Duality Gap for PSI (with Vi=0, Theta fixed and Zeta=B0)
C_psi = proxf.c_psi(Y, Theta0, B0, lambda_, mu, zeta)
dual_var_phi = None
dual_var_psi = None
B, Theta = B0, Theta0
B_diff = None
Theta_diff = None
B_prev = np.empty_like(B)
Theta_prev = np.empty_like(Theta)
for k in xrange(int(maxK)):
B_prev = B.copy()
Theta_prev = Theta.copy()
epsk = 1. / ((k + 1)**p)
# Option Const
eta = 1.
zeta = 1.
# Option DESCR
#eta = 1. / (k+1)
#zeta = 1. / (k+1)
# Option INCR
#eta = (k+1)
#zeta = (k+1)
# Theta update
Theta, phi_gaps, dual_var_phi = proxf.prox_phi(Theta,
eta,
B,
Y,
eps=C_phi * epsk,
maxN=maxN,
init=dual_var_phi)
# B update
B, psi_gaps, dual_var_psi = proxf.prox_psi(B,
zeta,
Theta,
Y,
mu,
lambda_,
eps=C_psi * epsk,
maxN=maxN,
init=dual_var_psi)
# Updating collections
callback(phi_gaps, psi_gaps, k, J, lambda_, mu)
B_diff = np.sum((B - B_prev)**2) / np.sum(B_prev**2)
if k == 0: #first iteration
Theta_diff = np.inf # -> more than eps
else:
Theta_diff = np.sum(
(Theta - Theta_prev)**2) / np.sum(Theta_prev**2)
# convergence
#if (B_diff <= eps and Theta_diff <= eps):
print(B_diff <= eps and Theta_diff <= eps)
# break
return {
'B': B,
'Theta': Theta,
'conv': k,
'gap_phi': phi_gaps[-1],
'gap_psi': psi_gaps[-1]
}
def minimize(Y,
J,
lambda_,
mu,
tau,
theta_bound=1.0,
tvw=None,
initB='pca',
initTheta=None,
maxK=200,
maxN=100,
eps=1e-3,
eps_gap='auto',
step=1.0):
L, S = Y.shape
#### B Initialization
try:
assert initB.shape == (L, J)
B0 = initB.copy()
except AttributeError:
assert initB in ['pca', 'rand']
B0 = utils.initB(Y, J, initB)
#### Theta Initialization
theta_bound = float(theta_bound)
try:
assert initTheta.shape == (J, S)
Theta0 = initTheta.copy()
except AttributeError:
#Theta0 = np.ones((J, S)) * theta_bound
Theta0 = np.zeros((J, S)) # for comparison with original FLLat
#### Total variation weigths
if tvw is None:
w = np.ones((L - 1, 1))
else:
w = tvw.reshape(L - 1, 1)
#### Precision
p = 1. # How to justify such a choice?
eta = 1. / (S * J)
zeta = 1. / (L * J)
# Parameters normalization
tau *= (L / float(J)) # s, j -- /J
lambda_ *= (S / float(J)) # l, j -- /S
mu *= (S / float(J)) # l, j -- /S
#### Starting Duality Gap for PHI (with Vi=0, B fixed and Gamma=Theta0)
C_phi = proxf.c_phi(Y, Theta0, B0, tau, eta, theta_bound)
#### Starting Duality Gap for PSI (with Vi=0, Theta fixed and Zeta=B0)
C_psi = proxf.c_psi(Y, Theta0, B0, lambda_, mu * w, zeta)
dual_var_phi = None
dual_var_psi = None
B, Theta = B0, Theta0
B_diff = None
Theta_diff = None
B_prev = np.empty_like(B)
Theta_prev = np.empty_like(Theta)
# Starting timer ----------------------------------------------------------
s_time = time.time()
for k in xrange(int(maxK)):
B_prev = B.copy()
Theta_prev = Theta.copy()
if eps_gap == 'auto':
epsk = {'phi': C_phi / ((k + 1)**p), 'psi': C_psi / ((k + 1)**p)}
else:
epsk = {'phi': eps_gap, 'psi': eps_gap}
if step == 'decr':
eta = 1. / (k + 1)
zeta = 1. / (k + 1)
elif step == 'incr':
eta = (k + 1)
zeta = (k + 1)
else:
eta = step
zeta = step
# Theta update
Theta, gap_phi, dual_var_phi, n_phi = proxf.prox_phi(Theta,
eta,
B,
Y,
tau,
bound=theta_bound,
eps=epsk['phi'],
maxN=maxN,
init=dual_var_phi)
# B update
B, gap_psi, dual_var_psi, n_psi = proxf.prox_psi(B,
zeta,
Theta,
Y,
mu * w,
lambda_,
eps=epsk['psi'],
maxN=maxN,
init=dual_var_psi)
B_diff = np.sum((B - B_prev)**2) / np.sum(B_prev**2)
if k == 0: #first iteration
Theta_diff = np.inf # -> more than eps
else:
Theta_diff = np.sum(
(Theta - Theta_prev)**2) / np.sum(Theta_prev**2)
# convergence
if (B_diff <= eps and Theta_diff <= eps):
break
return time.time() - s_time
def BIC_search(Y,
J_range,
lambda_range,
mu_range,
tau_range,
theta_bound=1.0,
tvw=None,
maxK=200,
maxN=100,
eps=1e-3,
eps_gap='auto',
step=1.0,
eps_jumps=1e-3,
callback=None):
"""
This function runs the **E-FLLat** algorithm for all possible combination of parameters and selects the best model (i.e. tuple of parameters) using the Bayesian information criterion (BIC).
Parameters
----------
Y : numpy.ndarray
The matrix representing all aCGH signals. Each column of the matrix represent a singla aCGH.
J_range : array_like
The list of all possible values for the parameter :math:`J`, representing the number of atoms which will be used for the reconstruction of the matrix.
lambda_range : array_like
All possible values for the :math:`\lambda` parameter.
mu_range : array_like
All possible values for the :math:`\mu` parameter.
tau_range : array_like
All possible values for the :math:`\tau` parameter.
theta_bound : float, optional (default: ``1.0``)
The value with which each entry of the :math:`\Theta` matrix will be initialized if it is not provided.
tvw : array_like, optional (default: ``None``)
An array containing the weights for the total variation term (when present).
maxK : int, optional (default: 200)
The maximum number of external iterations.
maxN : int, optional (default: 100)
The maximum number of internal iterations.
eps : float, optional (default: 1e-3)
The value used to stop the external iterations if neither of the two matrices changes more then this threshold.
eps_gap : string, optional (default: ``"auto"``)
The value used to stop the internal iterations when the solution does not change more than a fixed threshold between two iterations.
step : float, optional (default: 1.0)
A parameter controlling the step of internal iterations.
eps_jumps : float, optional (default: 1e-3)
The tolerance when computing the penalty for jumps in atoms.
callback, function, optional (default: ``None``)
If different from ``None``, the function is called at the end of each iteration and does something with the result obtained.
"""
import algorithm as alg
L, S = Y.shape
J_range = sorted(J_range)
mu_range = sorted(mu_range)
lambda_range = sorted(lambda_range)
tau_range = sorted(tau_range)
# Parameters dimensions
m, l, t = len(mu_range), len(lambda_range), len(tau_range)
# CGHDL params
params = {
'theta_bound': theta_bound,
'tvw': tvw,
'maxK': maxK,
'maxN': maxN,
'eps': eps,
'eps_gap': eps_gap,
'step': step
}
# Initialization
BIC_min = np.inf
B_res, Theta_res = None, None
J_res, mu_res, lambda_res, tau_res = None, None, None, None
for J in J_range:
# For each new J value we start from following B0 and Theta0
B0 = utils.initB(Y, J)
#Theta0 = np.ones((J, S)) * theta_bound
Theta0 = np.zeros((J, S)) # for comparison with original FLLat
# Evaluation
for j, i, k in it.product(range(l), range(m), range(t)):
result = alg.minimize(Y,
J,
lambda_=lambda_range[j],
mu=mu_range[i],
tau=tau_range[k],
initB=B0,
initTheta=Theta0,
**params)
B = result['B']
Theta = result['Theta']
# BIC calculation
fit = np.sum((Y - np.dot(B, Theta))**2.) / (S * L)
jumpsB = atoms_jumps(B, eps_jumps)
# fit # complexity
BIC = (S * L * np.log(fit)) + (jumpsB * np.log(S * L))
if BIC < BIC_min:
BIC_min = BIC
B_res, Theta_res = B, Theta
J_res, lambda_res, mu_res, tau_res = (J, lambda_range[j],
mu_range[i],
tau_range[k])
# Callback execution
if not callback is None:
callback(result, J, lambda_range[j], mu_range[i], tau_range[k],
BIC, eps_jumps)
# Return the best result
return {
'B': B_res,
'Theta': Theta_res,
'J': J_res,
'lambda': lambda_res,
'mu': mu_res,
'tau': tau_res,
'BIC': BIC_min
}
def minimize(Y,
J,
lambda_,
mu,
tau,
theta_bound=1.0,
tvw=None,
initB='pca',
initTheta=None,
maxK=200,
maxN=100,
eps=1e-3,
eps_gap='auto',
step=1.0):
L, S = Y.shape
#### B Initialization
try:
assert initB.shape == (L, J)
B0 = initB.copy()
except AttributeError:
assert initB in ['pca', 'rand']
B0 = utils.initB(Y, J, initB)
#### Theta Initialization
# Theta0 = np.zeros((J, S)) # <- default
# Parameters normalization
#lambda_ *= (S/float(J)) # l, j -- /S
#mu *= (S/float(J)) # l, j -- /S
lambda_ *= 2.0 * (S / float(J)) # l, j -- /S
mu *= 2.0 * (S / float(J)) # l, j -- /S
result = FLLat(
Y,
J=J,
B=B0,
lam1=lambda_,
lam2=mu,
thresh=eps, # 1e-4 (default)
maxiter=maxK, # 100 (default)
maxiter_B=maxN, # 1 ( // )
maxiter_T=maxN) # 1 ( // )
B = np.asarray(result.rx2('Beta'))
Theta = np.asarray(result.rx2('Theta'))
k = np.asarray(result.rx2('niter'))[0]
gap_phi = -np.inf # placeholders
gap_psi = -np.inf # --
return {
'B': B,
'Theta': Theta,
'conv': k,
'gap_phi': gap_phi,
'gap_psi': gap_psi,
'internal_iters': {
'phi': [-1],
'psi': [-1]
},
'C_phi': -1,
'C_psi': -1
}