def mapper(key, output_collector):
import mapreduce as GLOBAL
Xtr = GLOBAL.DATA_RESAMPLED["X"][0]
Xte = GLOBAL.DATA_RESAMPLED["X"][1]
ytr = GLOBAL.DATA_RESAMPLED["y"][0]
yte = GLOBAL.DATA_RESAMPLED["y"][1]
alpha, l1l2ratio = float(key[0]), float(key[1])
l1 = alpha * l1l2ratio
l2 = alpha * (1 - l1l2ratio)
print(key, alpha, l1, l2)
class_weight = 'auto' # unbiased
scaler = preprocessing.StandardScaler().fit(Xtr)
Xtr = scaler.transform(Xtr)
Xte = scaler.transform(Xte)
fista = algorithms.proximal.FISTA(max_iter=5000)
mod = estimators.ElasticNetLogisticRegression(l1l2ratio,
alpha,
algorithm=fista,
class_weight=class_weight,
penalty_start=penalty_start)
mod.fit(Xtr, ytr.ravel())
y_pred = mod.predict(Xte)
proba_pred = mod.predict_probability(Xte)
ret = dict(y_pred=y_pred, y_true=yte, proba_pred=proba_pred, beta=mod.beta)
if output_collector:
output_collector.collect(key, ret)
else:
return ret
def mapper(key, output_collector):
"""
# debug mapper
config = json.load(open(os.path.join(WD, "config_cv_largerange.json"), "r"))
load_globals(config)
resample(config, 'refit/refit')
key = ('enettv', 0.01, 0.1, 0.3)
"""
import mapreduce as GLOBAL
Xtr = GLOBAL.DATA_RESAMPLED["X"][0]
Xte = GLOBAL.DATA_RESAMPLED["X"][1]
ytr = GLOBAL.DATA_RESAMPLED["y"][0]
yte = GLOBAL.DATA_RESAMPLED["y"][1]
# key = 'enettv_0.01_0.1_0.2'.split("_")
algo, alpha, l1l2ratio, tvratio = key[0], float(key[1]), float(key[2]), float(key[3])
tv = alpha * tvratio
l1 = alpha * float(1 - tv) * l1l2ratio
l2 = alpha * float(1 - tv) * (1- l1l2ratio)
print(key, algo, alpha, l1, l2, tv)
# alpha = float(key[0])
# l1, l2, tv = alpha * float(key[1]), alpha * float(key[2]), alpha * float(key[3])
# print("l1:%f, l2:%f, tv:%f" % (l1, l2, tv))
class_weight = "auto" # unbiased
# mask = np.ones(Xtr.shape[0], dtype=bool)
scaler = preprocessing.StandardScaler().fit(Xtr)
Xtr = scaler.transform(Xtr)
Xte = scaler.transform(Xte)
if algo == 'enettv':
conesta = algorithms.proximal.CONESTA(max_iter=10000)
mod = estimators.LogisticRegressionL1L2TV(l1, l2, tv, GLOBAL.Atv,
algorithm=conesta, class_weight=class_weight, penalty_start=penalty_start)
mod.fit(Xtr, ytr.ravel())
elif algo == 'enetgn':
fista = algorithms.proximal.FISTA(max_iter=5000)
mod = estimators.LogisticRegressionL1L2GraphNet(l1, l2, tv, GLOBAL.Agn,
algorithm=fista, class_weight=class_weight, penalty_start=penalty_start)
mod.fit(Xtr, ytr.ravel())
elif algo == 'enet':
fista = algorithms.proximal.FISTA(max_iter=5000)
mod = estimators.ElasticNetLogisticRegression(l1l2ratio, alpha,
algorithm=fista, class_weight=class_weight, penalty_start=penalty_start)
mod.fit(Xtr, ytr.ravel())
else:
raise Exception('Algo%s not handled' %algo)
#mod.fit(Xtr, ytr.ravel())
y_pred = mod.predict(Xte)
proba_pred = mod.predict_probability(Xte)
ret = dict(y_pred=y_pred, y_true=yte, proba_pred=proba_pred,beta=mod.beta)
if output_collector:
output_collector.collect(key, ret)
else:
return ret
MODELS["2d_l2_inter_grad_descnt"] = \
estimators.RidgeLogisticRegression(alpha, class_weight=None,
mean=False,
penalty_start=1,
algorithm_params=algorithm_params)
if has_sklearn:
MODELS["2d_l1_sklearn"] = \
sklearn.linear_model.LogisticRegression(C=1. / alpha, penalty="l1",
fit_intercept=False,
class_weight=None,
dual=False,
solver="liblinear")
MODELS["2d_l1_fista"] = \
estimators.ElasticNetLogisticRegression(alpha=alpha, l=1.,
class_weight=None,
mean=False,
algorithm_params=algorithm_params)
if has_sklearn:
MODELS["2d_l1_inter_sklearn"] = \
sklearn.linear_model.LogisticRegression(C=1. / alpha, penalty="l1",
fit_intercept=True,
class_weight=None,
dual=False,
solver="liblinear")
MODELS["2d_l1_inter_fista"] = \
estimators.ElasticNetLogisticRegression(alpha=alpha, l=1.,
class_weight=None,
mean=False,
penalty_start=1,
ridge_sklrn = LogisticRegression(C=1. / (alpha * n_train), fit_intercept=False)
yte_pred_ridge = ridge_sklrn.fit(Xtr, ytr.ravel()).predict(Xte)
_, recall_ridge_sklrn, _, _ = \
precision_recall_fscore_support(yte, yte_pred_ridge, average=None)
# Ridge Parsimony
# Min f(beta, X, y) = - loglik/n_train + k/2 * ||beta||^2_2
ridge_prsmy = estimators.RidgeLogisticRegression(alpha)
yte_pred_ridge_prsmy = ridge_prsmy.fit(Xtr, ytr).predict(Xte)
_, recall_ridge_prsmy, _, _ = \
precision_recall_fscore_support(yte, yte_pred_ridge_prsmy, average=None)
# EldasticNet
enet = estimators.ElasticNetLogisticRegression(l=0.5, alpha=alpha)
yte_pred_enet = enet.fit(Xtr, ytr).predict(Xte)
_, recall_enet, _, _ = \
precision_recall_fscore_support(yte, yte_pred_enet, average=None)
# GraphNet
# l1, l2, gn = alpha * np.array((.05, .75, .2)) # l1, l2, gn penalties
l1, l2, gn = alpha * np.array((.33, .33, 33)) # l1, l2, gn penalties
A = sparse.vstack(nesterov_tv.linear_operator_from_shape(shape))
enetgn = estimators.LogisticRegressionL1L2GraphNet(l1, l2, gn, A)
yte_pred_enetgn = enetgn.fit(Xtr, ytr).predict(Xte)
_, recall_enetgn, _, _ = \
precision_recall_fscore_support(yte, yte_pred_enetgn, average=None)
# LogisticRegressionL1L2TV
l1, l2, tv = alpha * np.array((.05, .75, .2)) # l1, l2, tv penalties
#
#'enetgn':
tvratio=0.8
l1l2ratio = 0.1
alpha = 0.1
tv = alpha * tvratio
l1 = alpha * float(1 - tv) * l1l2ratio
l2 = alpha * float(1 - tv) * (1- l1l2ratio)
fista = algorithms.proximal.FISTA(max_iter=5000)
mod = estimators.LogisticRegressionL1L2GraphNet(l1, l2, tv,Agn,
algorithm=fista, class_weight=class_weight, penalty_start=penalty_start)
#algo == 'enet':
fista = algorithms.proximal.FISTA(max_iter=5000)
mod = estimators.ElasticNetLogisticRegression(0.01,0.1)
algorithm=fista, class_weight=class_weight, penalty_start=penalty_start)
mod.fit(X_scz,y_scz)
y_pred_pra = mod.predict(X_pra)
y_proba_pred_pra = mod.predict_probability(X_pra)
p, r, f, s = precision_recall_fscore_support(y_pra, y_pred_pra, average=None)
auc = roc_auc_score(y_pra, y_proba_pred_pra)
print("######################################")
print("Classification performance on PRAGUE dataset:")
print("Balanced accuracy : " + str(r.mean()))
print("Spe and Sen : " + str(r[0]) + " " + str(r[1]))
l1 = alpha * float(1 - tv) * l1l2ratio
l2 = alpha * float(1 - tv) * (1 - l1l2ratio)
fista = algorithms.proximal.FISTA(max_iter=5000)
mod = estimators.LogisticRegressionL1L2GraphNet(l1,
l2,
tv,
Agn,
algorithm=fista,
class_weight=class_weight,
penalty_start=penalty_start)
#algo == 'enet':
fista = algorithms.proximal.FISTA(max_iter=5000)
mod = estimators.ElasticNetLogisticRegression(0.1,
0.1,
algorithm=fista,
class_weight=class_weight,
penalty_start=penalty_start)
mod.fit(X_scz, y_scz)
y_pred_pra = mod.predict(X_pra)
y_proba_pred_pra = mod.predict_probability(X_pra)
p, r, f, s = precision_recall_fscore_support(y_pra, y_pred_pra, average=None)
auc = roc_auc_score(y_pra, y_proba_pred_pra)
print("######################################")
print("Classification performance on PRAGUE dataset:")
print("Balanced accuracy : " + str(r.mean()))
print("Spe and Sen : " + str(r[0]) + " " + str(r[1]))
print("AUC : " + str(auc))
def mapper(key, output_collector):
import mapreduce as GLOBAL
Xtr = GLOBAL.DATA_RESAMPLED["X"][0]
Xte = GLOBAL.DATA_RESAMPLED["X"][1]
ytr = GLOBAL.DATA_RESAMPLED["y"][0]
yte = GLOBAL.DATA_RESAMPLED["y"][1]
# key = 'enettv_0.01_0.1_0.2'.split("_")
algo, alpha, l1l2ratio, tvratio = key[0], float(key[1]), float(
key[2]), float(key[3])
tv = alpha * tvratio
l1 = alpha * float(1 - tv) * l1l2ratio
l2 = alpha * float(1 - tv) * (1 - l1l2ratio)
print(key, algo, alpha, l1, l2, tv)
# alpha = float(key[0])
# l1, l2, tv = alpha * float(key[1]), alpha * float(key[2]), alpha * float(key[3])
# print("l1:%f, l2:%f, tv:%f" % (l1, l2, tv))
class_weight = "auto" # unbiased
beta_start = GLOBAL.beta_start["lambda_%.4f" % alpha]
print(beta_start.shape, Xtr.shape, beta_start.mean())
# mask = np.ones(Xtr.shape[0], dtype=bool)
scaler = preprocessing.StandardScaler().fit(Xtr)
Xtr = scaler.transform(Xtr)
Xte = scaler.transform(Xte)
if algo == 'enettv':
conesta = algorithms.proximal.CONESTA(max_iter=10000)
mod = estimators.LogisticRegressionL1L2TV(l1,
l2,
tv,
GLOBAL.Atv,
algorithm=conesta,
class_weight=class_weight,
penalty_start=penalty_start)
mod.fit(Xtr, ytr.ravel(), beta=beta_start)
elif algo == 'enetgn':
fista = algorithms.proximal.FISTA(max_iter=500)
mod = estimators.LogisticRegressionL1L2GraphNet(
l1,
l2,
tv,
GLOBAL.Agn,
algorithm=fista,
class_weight=class_weight,
penalty_start=penalty_start)
mod.fit(Xtr, ytr.ravel())
elif algo == 'enet':
fista = algorithms.proximal.FISTA(max_iter=500)
mod = estimators.ElasticNetLogisticRegression(
l1l2ratio,
alpha,
algorithm=fista,
class_weight=class_weight,
penalty_start=penalty_start)
mod.fit(Xtr, ytr.ravel())
else:
raise Exception('Algo%s not handled' % algo)
#mod.fit(Xtr, ytr.ravel())
y_pred = mod.predict(Xte)
proba_pred = mod.predict_probability(Xte)
ret = dict(y_pred=y_pred, y_true=yte, proba_pred=proba_pred,
beta=mod.beta) #, mask=mask)
if output_collector:
output_collector.collect(key, ret)
else:
return ret
