def paral_fun_L1(K_train, Z, model, m, eta, eta_tilde, mid_mat, e, w, Lambda):
Nsamp = K_train.shape[0]
# working Lambda
new_Lambda = Lambda / 2 # due to setting of sklearn.linear_model.Lasso
# get K
Km = get_K(K_train, m)
# transform K for penalized regression
Km_tilde = mid_mat.dot(Km)
# get beta
lasso_fit = linear_model.Lasso(alpha = new_Lambda,fit_intercept = False,\
selection='random',max_iter=200,tol=10**-4)
lasso_fit.fit(-Km_tilde, eta_tilde)
beta = lasso_fit.coef_
#get gamma
if model.problem in ('classification', 'survival'):
if model.problem == 'survival' and not model.hasClinical:
gamma = np.array([0.0])
else:
gamma = -np.linalg.solve(Z.T.dot(w).dot(Z),
Z.T.dot(w)).dot(eta + Km.dot(beta))
elif model.problem == 'regression':
gamma = -e.dot(eta + Km.dot(beta))
# calculate val
val = np.sum((eta_tilde + Km_tilde.dot(beta))**
2) + Lambda * Nsamp * np.sum(np.abs(beta))
return [val, [m, beta, gamma]]
def paral_fun_L2(K_train, Z, model, m, eta, eta_tilde, mid_mat, e, w, Lambda):
Nsamp = K_train.shape[0]
# working Lambda
new_Lambda = Nsamp * Lambda
# get K
Km = get_K(K_train, m)
# transform Km
Km_tilde = mid_mat.dot(Km)
# L2 solution
beta = -np.linalg.solve(
Km_tilde.T.dot(Km_tilde) + np.eye(Nsamp) * new_Lambda,
Km_tilde.T.dot(eta_tilde))
#get gamma
if model.problem in ('classification', 'survival'):
if model.problem == 'survival' and not model.hasClinical:
gamma = np.array([0.0])
else:
gamma = -np.linalg.solve(Z.T.dot(w).dot(Z),
Z.T.dot(w)).dot(eta + Km.dot(beta))
elif model.problem == 'regression':
#gamma = - np.linalg.solve(Z.T.dot(Z), Z.T).dot(eta + Km.dot(beta))
gamma = -e.dot(eta + Km.dot(beta))
val = np.sum(
(eta_tilde + Km_tilde.dot(beta))**2) + new_Lambda * np.sum(beta**2)
return [val, [m, beta, gamma]]
def paral_fun_L2(sharedK, Z, model, m, nrow, h, q, Lambda, sele_loc):
# get K
Km = get_K(sharedK, m, nrow, sele_loc)
if model.problem in ('classification', 'survival'):
# working Lambda
new_Lambda = len(sele_loc) * Lambda
# convert eta, Km
eta = model.calcu_eta(h, q)
w = model.calcu_w(q)
w_half = model.calcu_w_half(q)
mid_mat = np.eye(len(sele_loc)) - Z.dot(
np.linalg.solve(Z.T.dot(w).dot(Z), Z.T.dot(w)))
eta_tilde = w_half.dot(mid_mat).dot(eta)
Km_tilde = w_half.dot(mid_mat).dot(Km)
elif model.problem == 'regression':
# working Lambda
new_Lambda = len(sele_loc) * Lambda
e = np.linalg.solve(Z.T.dot(Z), np.eye(Z.shape[1])).dot(Z.T)
eta = model.calcu_eta(Z)
mid_mat = np.eye(len(sele_loc)) - Z.dot(e)
#mid_mat = np.eye(len(sele_loc)) - Z.dot( np.linalg.solve(Z.T.dot(Z), Z.T) )
eta_tilde = mid_mat.dot(eta)
Km_tilde = mid_mat.dot(Km)
# L2 solution
#===========================================================================
# print("L2 solution")
# print(Km_tilde)
# print(Km_tilde.T.dot(Km_tilde))
#===========================================================================
tmp_mat1 = Km_tilde.T.dot(Km_tilde)
tmp_mat = Km_tilde.T.dot(Km_tilde) + np.eye(len(sele_loc)) * new_Lambda
#sol = scipy.linalg.inv(tmp_mat)
#sol = np.linalg.inv(tmp_mat,np.eye(tmp_mat.shape[0]))
#print("solved")
#beta = - scipy.linalg.inv(tmp_mat,np.eye(tmp_mat.shape[0])).dot(Km_tilde.T.dot(eta_tilde))
#===========================================================================
# try:
# inverse = np.linalg.inv(tmp_mat)
# print("Yeah!")
# except np.linalg.LinAlgError:
# pass
#===========================================================================
#beta = - scipy.linalg.inv(tmp_mat).dot(Km_tilde.T.dot(eta_tilde))
beta = -np.linalg.solve(
Km_tilde.T.dot(Km_tilde) + np.eye(len(sele_loc)) * new_Lambda,
Km_tilde.T.dot(eta_tilde))
#get gamma
if model.problem in ('classification', 'survival'):
gamma = -np.linalg.solve(Z.T.dot(w).dot(Z),
Z.T.dot(w)).dot(eta + Km.dot(beta))
elif model.problem == 'regression':
#gamma = - np.linalg.solve(Z.T.dot(Z), Z.T).dot(eta + Km.dot(beta))
gamma = -e.dot(eta + Km.dot(beta))
val = np.sum(
(eta_tilde + Km_tilde.dot(beta))**2) + new_Lambda * np.sum(beta**2)
return [val, [m, beta, gamma]]
def paral_fun_L1(sharedK, Z, model, m, nrow, h, q, Lambda, sele_loc):
# working Lambda
new_Lambda = Lambda / 2 # due to setting of sklearn.linear_model.Lasso
# get K
Km = get_K(sharedK, m, nrow, sele_loc)
# transform eta, K for penalized regression
if model.problem in ('classification', 'survival'):
eta = model.calcu_eta(h, q)
w = model.calcu_w(q)
w_half = model.calcu_w_half(q)
mid_mat = np.eye(len(sele_loc)) - Z.dot(
np.linalg.solve(Z.T.dot(w).dot(Z), Z.T.dot(w)))
eta_tilde = w_half.dot(mid_mat).dot(eta)
Km_tilde = w_half.dot(mid_mat).dot(Km)
elif model.problem == 'regression':
# calculate rt (eta)
eta = model.calcu_eta(Z)
e = np.linalg.solve(Z.T.dot(Z), np.eye(Z.shape[1])).dot(Z.T)
mid_mat = np.eye(len(sele_loc)) - Z.dot(e)
eta_tilde = mid_mat.dot(eta)
Km_tilde = mid_mat.dot(Km)
# get beta
lasso_fit = linear_model.Lasso(alpha = new_Lambda,fit_intercept = False,\
selection='random',max_iter=20000,tol=10**-4)
lasso_fit.fit(-Km_tilde, eta_tilde)
beta = lasso_fit.coef_
#get gamma
if model.problem in ('classification', 'survival'):
gamma = -np.linalg.solve(Z.T.dot(w).dot(Z),
Z.T.dot(w)).dot(eta + Km.dot(beta))
elif model.problem == 'regression':
gamma = -e.dot(eta + Km.dot(beta))
# calculate val
val = np.sum((eta_tilde + Km_tilde.dot(beta))**
2) + Lambda * len(sele_loc) * np.sum(np.abs(beta))
return [val, [m, beta, gamma]]