def one_edge_tv(coord_ij, tria_ij, data_ij, Y_ij, params):
A_ij = tv.linear_operator_from_mesh(coord_ij, tria_ij)
X_train, X_test, y_train, y_test = train_test_split(data_ij,
Y_ij,
shuffle=True,
random_state=1,
test_size=0.33)
tv_reg = LinearRegressionL1L2TV(l1=params['l1'],
l2=params['l2'],
tv=params['tv'],
A=A_ij)
tv_reg.fit(X_train, y_train)
y_train_pred = tv_reg.predict(X_train)
y_test_pred = tv_reg.predict(X_test)
mse_test = mean_squared_error(y_test, y_test_pred)
r2_test = r2_score(y_test, y_test_pred_tv)
print('TRAIN MSE TV: {}, TEST MSE TV: {}'.format(
mean_squared_error(y_train, y_train_pred), mse_test))
print('TRAIN R2 TV: {}, TEST R2 TV: {}\n'.format(
r2_score(y_train, y_train_pred), r2_test))
return r2_test
def mapper(key, output_collector):
import mapreduce as GLOBAL # access to global variables:
#raise ImportError("could not import ")
# GLOBAL.DATA, GLOBAL.STRUCTURE, GLOBAL.A
# GLOBAL.DATA ::= {"X":[Xtrain, Xtest], "y":[ytrain, ytest]}
# key: list of parameters
Xtr = GLOBAL.DATA_RESAMPLED["X"][0]
Xte = GLOBAL.DATA_RESAMPLED["X"][1]
ytr = GLOBAL.DATA_RESAMPLED["y"][0]
yte = GLOBAL.DATA_RESAMPLED["y"][1]
print key, "Data shape:", Xtr.shape, Xte.shape, ytr.shape, yte.shape
STRUCTURE = GLOBAL.STRUCTURE
n_voxels = np.count_nonzero(STRUCTURE.get_data())
penalty_start = GLOBAL.PENALTY_START
alpha = float(key[0])
l1, l2 = alpha * float(key[1]), alpha * float(key[2])
tv, k_ratio = alpha * float(key[3]), key[4]
print "l1:%f, l2:%f, tv:%f, k_ratio:%f" % (l1, l2, tv, k_ratio)
if k_ratio != 1:
k = n_voxels * k_ratio
k = int(k)
aov = SelectKBest(k=k)
aov.fit(Xtr[..., penalty_start:], ytr.ravel())
mask = STRUCTURE.get_data() != 0
mask[mask] = aov.get_support()
#print mask.sum()
A, _ = tv_helper.A_from_mask(mask)
Xtr_r = np.hstack([
Xtr[:, :penalty_start], Xtr[:, penalty_start:][:,
aov.get_support()]
])
Xte_r = np.hstack([
Xte[:, :penalty_start], Xte[:, penalty_start:][:,
aov.get_support()]
])
else:
mask = STRUCTURE.get_data() != 0
Xtr_r = Xtr
Xte_r = Xte
A = GLOBAL.A
info = [Info.num_iter]
mod = LinearRegressionL1L2TV(l1,
l2,
tv,
A,
penalty_start=penalty_start,
algorithm_params={'info': info})
mod.fit(Xtr_r, ytr)
y_pred = mod.predict(Xte_r)
beta = mod.beta
ret = dict(y_pred=y_pred,
y_true=yte,
beta=beta,
n_iter=mod.get_info()['num_iter'])
if output_collector:
output_collector.collect(key, ret)
else:
return ret
def mapper(key, output_collector):
import mapreduce as GLOBAL # access to global variables:
#raise ImportError("could not import ")
# GLOBAL.DATA, GLOBAL.STRUCTURE, GLOBAL.A
# GLOBAL.DATA ::= {"X":[Xtrain, ytrain], "y":[Xtest, ytest]}
# key: list of parameters
Xtr = GLOBAL.DATA_RESAMPLED["X"][0]
Xte = GLOBAL.DATA_RESAMPLED["X"][1]
ytr = GLOBAL.DATA_RESAMPLED["y"][0]
yte = GLOBAL.DATA_RESAMPLED["y"][1]
print key, "Data shape:", Xtr.shape, Xte.shape, ytr.shape, yte.shape
STRUCTURE = GLOBAL.STRUCTURE
#alpha, ratio_l1, ratio_l2, ratio_tv, k = key
#key = np.array(key)
penalty_start = GLOBAL.CONFIG["penalty_start"]
#class_weight="auto" # unbiased
alpha = float(key[0])
l1, l2, tv, k = alpha * float(key[1]), alpha * float(
key[2]), alpha * float(key[3]), key[4]
print "l1:%f, l2:%f, tv:%f, k:%i" % (l1, l2, tv, k)
if k != -1:
k = int(k)
aov = SelectKBest(k=k)
aov.fit(Xtr[..., penalty_start:], ytr.ravel())
mask = STRUCTURE.get_data() != 0
mask[mask] = aov.get_support()
#print mask.sum()
A, _ = tv_helper.A_from_mask(mask)
Xtr_r = np.hstack([
Xtr[:, :penalty_start], Xtr[:, penalty_start:][:,
aov.get_support()]
])
Xte_r = np.hstack([
Xte[:, :penalty_start], Xte[:, penalty_start:][:,
aov.get_support()]
])
else:
mask = np.ones(Xtr.shape[0], dtype=bool)
Xtr_r = Xtr
Xte_r = Xte
A = GLOBAL.A
mod = LinearRegressionL1L2TV(l1, l2, tv, A, penalty_start=penalty_start)
mod.fit(Xtr_r, ytr)
y_pred = mod.predict(Xte_r)
ret = dict(y_pred=y_pred, y_true=yte, beta=mod.beta, mask=mask)
if output_collector:
output_collector.collect(key, ret)
else:
return ret