def test_fista_regression_simplex():
rng = np.random.RandomState(0)
w = project_simplex(rng.rand(10))
X = rng.randn(1000, 10)
y = np.dot(X, w)
reg = FistaRegressor(penalty="simplex", max_iter=100, verbose=0)
reg.fit(X, y)
y_pred = reg.predict(X)
error = np.sqrt(np.mean((y - y_pred)**2))
assert_almost_equal(error, 0.000, 3)
assert_true(np.all(reg.coef_ >= 0))
assert_almost_equal(np.sum(reg.coef_), 1.0, 3)
def test_fista_regression_simplex():
rng = np.random.RandomState(0)
w = project_simplex(rng.rand(10))
X = rng.randn(1000, 10)
y = np.dot(X, w)
reg = FistaRegressor(penalty="simplex", max_iter=100, verbose=0)
reg.fit(X, y)
y_pred = reg.predict(X)
error = np.sqrt(np.mean((y - y_pred) ** 2))
assert_almost_equal(error, 0.000, 3)
assert_true(np.all(reg.coef_ >= 0))
assert_almost_equal(np.sum(reg.coef_), 1.0, 3)
def test_fista_regression_l1_ball():
rng = np.random.RandomState(0)
alpha = 5.0
w = project_simplex(rng.randn(10), alpha)
X = rng.randn(1000, 10)
y = np.dot(X, w)
reg = FistaRegressor(penalty="l1-ball", alpha=alpha, max_iter=100, verbose=0)
reg.fit(X, y)
y_pred = reg.predict(X)
error = np.sqrt(np.mean((y - y_pred) ** 2))
np.testing.assert_almost_equal(error, 0.000, 3)
np.testing.assert_almost_equal(np.sum(np.abs(reg.coef_)), alpha, 3)
def test_fista_regression_l1_ball():
rng = np.random.RandomState(0)
alpha = 5.0
w = project_simplex(rng.randn(10), alpha)
X = rng.randn(1000, 10)
y = np.dot(X, w)
reg = FistaRegressor(penalty="l1-ball", alpha=alpha, max_iter=100, verbose=0)
reg.fit(X, y)
y_pred = reg.predict(X)
error = np.sqrt(np.mean((y - y_pred) ** 2))
assert_almost_equal(error, 0.000, 3)
assert_almost_equal(np.sum(np.abs(reg.coef_)), alpha, 3)
def test_fista_regression_trace():
rng = np.random.RandomState(0)
def _make_data(n_samples, n_features, n_tasks, n_components):
W = rng.rand(n_tasks, n_features) - 0.5
U, S, V = svd(W, full_matrices=True)
S[n_components:] = 0
S = diagsvd(S, U.shape[0], V.shape[0])
W = np.dot(np.dot(U, S), V)
X = rng.rand(n_samples, n_features) - 0.5
Y = np.dot(X, W.T)
return X, Y, W
X, Y, W = _make_data(200, 50,30, 5)
reg = FistaRegressor(max_iter=15, verbose=0)
reg.fit(X, Y)
Y_pred = reg.predict(X)
error = (Y_pred - Y).ravel()
error = np.dot(error, error)
assert_almost_equal(error, 77.45, 2)
def fit(self, X, y):
if self.w is None:
self.w = np.ones(X.shape[1])
if self.lam is None:
lam_max, lam_min = _get_lam_max_min(X, y, self.eps)
self.lambda_path_ = np.logspace(np.log10(lam_max), np.log10(lam_min), self.n_lam)
else:
self.lambda_path_ = [self.lam]
scorer = make_scorer(self.metric)
self.coef_path_, self.model_path_, self.score_path_ = [], [], []
for lam_i in self.lambda_path_:
# Setup model
per_model_n = len(y) * ((self.cv-1) / self.cv)
model_i = FistaRegressor(
C=1/per_model_n,
penalty=_LassoProjection(self.w),
alpha=lam_i
)
# Get fit data
scores_i = cross_val_score(
model_i,
X, y,
scoring=scorer,
cv=self.cv,
n_jobs=self.n_jobs
)
# Fit model
model_i.fit(X, y)
self.coef_path_.append(model_i.coef_)
self.score_path_.append(scores_i.mean())
self.model_path_.append(model_i)
self.coef_path_ = np.vstack(self.coef_path_)
self.best_index = np.argmin(self.score_path_)
def test_fista_regression():
reg = FistaRegressor(max_iter=100, verbose=0)
reg.fit(bin_dense, bin_target)
y_pred = np.sign(reg.predict(bin_dense))
assert_almost_equal(np.mean(bin_target == y_pred), 0.985)
def test_fista_regression():
reg = FistaRegressor(max_iter=100, verbose=0)
reg.fit(bin_dense, bin_target)
y_pred = np.sign(reg.predict(bin_dense))
assert_almost_equal(np.mean(bin_target == y_pred), 0.985)
def test_fista_regression(bin_dense_train_data):
X, y = bin_dense_train_data
reg = FistaRegressor(max_iter=100, verbose=0)
reg.fit(X, y)
y_pred = np.sign(reg.predict(X))
np.testing.assert_almost_equal(np.mean(y == y_pred), 0.985)
def estimator(A_val, y_batch_val, hparams):
if A_val is None:
A = np.eye(y_batch_val.shape[1]) #TODO remove idle
else:
A = A_val.T
mode = hparams.tv_or_lasso_mode
y = utils_lasso.get_y(mode,y_batch_val,A)
W = utils_lasso.load_W(hparams, A, y)
x_hat_batch = []
if W is None:
AW = A
else:
if W is None or 'tv-norm' in hparams.model_types:
AW = None
else:
AW = A.dot(W)
if 'fista' in mode:
clf1 = FistaRegressor(penalty='l1')
gs = GridSearchCV(clf1, {'alpha': np.logspace(-3, 3, 10)})
gs.fit(AW, y)
x_hat_batch = gs.best_estimator_.coef_.dot(W)#.T
elif 'cvxpy' in mode:
maxit = utils_lasso.get_key('reweight',mode,int)
weight = np.array([])
errors = []
for it in range(maxit):
if maxit >1:
print('Computing reweighting iteration: {}'.format(it+1))
x_hat_batch,weight = utils_lasso.cvxpy_problem(mode,W,A,AW,y,weight)
current_error = np.mean(utils.get_l2_loss(np.array(hparams.x),utils_lasso.get_x(mode,x_hat_batch)))#np.mean(np.mean((np.array(hparams.x)-x_hat_batch)**2,axis=1))
errors.append(current_error)
print('Current error: {}'.format(current_error))
if maxit>1:
errors = np.array(errors)
np.save(utils.get_checkpoint_dir(hparams, hparams.model_types[0])+'error_course',errors)
elif 'cvxopt' in mode:
for i in range(hparams.batch_size):
y_val = y_batch_val[i]
x_hat = utils_lasso.tv_cvxopt_partial(A_val, y_val,hparams)
x_hat_batch.append(x_hat)
print('Processed {} percent of all images'.format(float(i+1)/hparams.batch_size*100))
x_hat_batch = np.asarray(x_hat_batch)
elif 'sklearn' in mode:
for i in range(hparams.batch_size):
y_val = y_batch_val[i]
x_hat = utils.solve_lasso(A_val, y_val, hparams)
x_hat = np.maximum(np.minimum(x_hat, 1), 0)
x_hat_batch.append(x_hat)
print('Processed {} percent of all images'.format(float(i+1)/hparams.batch_size*100))
x_hat_batch = np.asarray(x_hat_batch)
elif 'bestkTermApprox' in mode:
for i in range(hparams.batch_size):
y_val = y_batch_val[i]
x_hat = utils_lasso.check_bestkTermApprox(mode, W, y_val)
x_hat = np.maximum(np.minimum(x_hat, 1), 0)
x_hat_batch.append(x_hat)
print('Processed {} percent of all images'.format(float(i+1)/hparams.batch_size*100))
x_hat_batch = np.asarray(x_hat_batch)
elif 'bruteForce' in mode: #slithly redundant to above
for i in range(hparams.batch_size):
y_val = y_batch_val[i]
x_hat = utils_lasso.brute_force(mode, A_val,W,y_val)
x_hat = np.maximum(np.minimum(x_hat, 1), 0)
x_hat_batch.append(x_hat)
print('Processed {} percent of all images'.format(float(i+1)/hparams.batch_size*100))
x_hat_batch = np.asarray(x_hat_batch)
else:
raise NotImplementedError('Mode {} does not exist!'.format(mode))
return utils_lasso.get_x(mode,x_hat_batch)
