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)
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.LinearRegressionL1L2TV(l1,
l2,
tv,
GLOBAL.Atv,
algorithm=conesta)
mod.fit(Xtr, ytr.ravel())
elif algo == 'enetgn':
fista = algorithms.proximal.FISTA(max_iter=5000)
mod = estimators.LinearRegressionL1L2GraphNet(l1,
l2,
tv,
GLOBAL.Agn,
algorithm=fista)
mod.fit(Xtr, ytr.ravel())
elif algo == 'enet':
fista = algorithms.proximal.FISTA(max_iter=5000)
mod = estimators.ElasticNet(l1l2ratio, algorithm=fista)
mod.fit(Xtr, ytr.ravel())
else:
raise Exception('Algo%s not handled' % algo)
#mod.fit(Xtr, ytr.ravel())
y_pred = mod.predict(Xte)
ret = dict(y_pred=y_pred, y_true=yte, beta=mod.beta)
if output_collector:
output_collector.collect(key, ret)
else:
return ret
Xte = X[n_train:, :]
yte = y[n_train:]
alpha = 1. # global penalty
###############################################################################
# Estimators
# Fit RidgeRegression
rr = estimators.RidgeRegression(l=alpha)
rr.fit(Xtr, ytr)
yte_pred_rr = rr.fit(Xtr, ytr).predict(Xte)
# Fit GraphNet
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.LinearRegressionL1L2GraphNet(l1, l2, gn, A)
yte_pred_enetgn = enetgn.fit(Xtr, ytr).predict(Xte)
# Fit LinearRegressionL1L2TV
l1, l2, tv = alpha * np.array((.33, .33, .33)) # l1, l2, tv penalties
Atv = nesterov_tv.linear_operator_from_shape(shape)
enettv = estimators.LinearRegressionL1L2TV(l1,
l2,
tv,
Atv,
algorithm_params=dict(max_iter=500))
yte_pred_enettv = enettv.fit(Xtr, ytr).predict(Xte)
###############################################################################
# Plot
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)
scaler = preprocessing.StandardScaler().fit(Xtr[:, 1:])
Xtr[:, 1:] = scaler.transform(Xtr[:, 1:])
Xte[:, 1:] = scaler.transform(Xte[:, 1:])
if algo == 'enettv':
conesta = algorithms.proximal.CONESTA(max_iter=10000)
mod = estimators.LinearRegressionL1L2TV(l1,
l2,
tv,
GLOBAL.Atv,
algorithm=conesta,
penalty_start=penalty_start)
mod.fit(Xtr, ytr.ravel())
beta = mod.beta
elif algo == 'enetgn':
fista = algorithms.proximal.FISTA(max_iter=5000)
mod = estimators.LinearRegressionL1L2GraphNet(
l1,
l2,
tv,
GLOBAL.Agn,
algorithm=fista,
penalty_start=penalty_start)
mod.fit(Xtr, ytr.ravel())
beta = mod.beta
elif algo == 'enet':
fista = algorithms.proximal.FISTA(max_iter=5000)
mod = estimators.ElasticNet(l1l2ratio,
algorithm=fista,
penalty_start=penalty_start)
mod.fit(Xtr, ytr.ravel())
beta = mod.beta
elif algo == 'Ridge':
mod = estimators.RidgeRegression(l1l2ratio,
penalty_start=penalty_start)
mod.fit(Xtr, ytr.ravel())
beta = mod.beta
elif algo == 'RidgeAGD':
mod = estimators.RidgeRegression(l1l2ratio,\
algorithm=gradient.GradientDescent(max_iter=1000),penalty_start = penalty_start )
mod.fit(Xtr, ytr.ravel())
beta = mod.beta
elif algo == 'linearSklearn':
mod = linear_model.LinearRegression(fit_intercept=False)
mod.fit(Xtr, ytr.ravel())
beta = mod.coef_
beta = beta.reshape(beta.shape[0], 1)
elif algo == 'SkRidge':
mod = linear_model.Ridge(alpha=l1l2ratio, fit_intercept=False)
mod.fit(Xtr, ytr.ravel())
beta = mod.coef_
beta = beta.reshape(beta.shape[0], 1)
elif algo == 'SkRidgeInt':
mod = linear_model.Ridge(alpha=l1l2ratio, fit_intercept=True)
mod.fit(Xtr, ytr.ravel())
beta = mod.coef_
beta = beta.reshape(beta.shape[0], 1)
else:
raise Exception('Algo%s not handled' % algo)
y_pred = mod.predict(Xte)
ret = dict(y_pred=y_pred, y_true=yte, beta=beta)
if output_collector:
output_collector.collect(key, ret)
else:
return ret
