y += 0.01*np.random.normal((n_samples,))
# Split data in train set and test set
n_samples = X.shape[0]
X_train, y_train = X[:n_samples/2], y[:n_samples/2]
X_test, y_test = X[n_samples/2:], y[n_samples/2:]
################################################################################
# Lasso
from scikits.learn.linear_model import Lasso
alpha = 0.1
lasso = Lasso(alpha=alpha)
y_pred_lasso = lasso.fit(X_train, y_train).predict(X_test)
print lasso
print "r^2 on test data : %f" % (1 - np.linalg.norm(y_test - y_pred_lasso)**2
/ np.linalg.norm(y_test)**2)
################################################################################
# ElasticNet
from scikits.learn.linear_model import ElasticNet
enet = ElasticNet(alpha=alpha, rho=0.7)
y_pred_enet = enet.fit(X_train, y_train).predict(X_test)
print enet
print "r^2 on test data : %f" % (1 - np.linalg.norm(y_test - y_pred_enet)**2
/ np.linalg.norm(y_test)**2)
X_train = X_train[idx]
y_train = y_train[idx]
std = X_train.std(axis=0)
mean = X_train.mean(axis=0)
X_train = (X_train - mean) / std
X_test = (X_test - mean) / std
std = y_train.std(axis=0)
mean = y_train.mean(axis=0)
y_train = (y_train - mean) / std
y_test = (y_test - mean) / std
gc.collect()
print "- benching ElasticNet"
clf = ElasticNet(alpha=alpha, rho=0.5, fit_intercept=False)
tstart = time()
clf.fit(X_train, y_train)
elnet_results[i, j, 0] = mean_square_error(clf.predict(X_test),
y_test)
elnet_results[i, j, 1] = time() - tstart
gc.collect()
print "- benching SGD"
n_iter = np.ceil(10 ** 4.0 / n_train)
clf = SGDRegressor(alpha=alpha, fit_intercept=False,
n_iter=n_iter, learning_rate="invscaling",
eta0=.01, power_t=0.25)
tstart = time()
clf.fit(X_train, y_train)
# add noise
y += 0.01 * np.random.normal((n_samples, ))
# Split data in train set and test set
n_samples = X.shape[0]
X_train, y_train = X[:n_samples / 2], y[:n_samples / 2]
X_test, y_test = X[n_samples / 2:], y[n_samples / 2:]
################################################################################
# Lasso
from scikits.learn.linear_model import Lasso
alpha = 0.1
lasso = Lasso(alpha=alpha)
y_pred_lasso = lasso.fit(X_train, y_train).predict(X_test)
print lasso
print "r^2 on test data : %f" % (
1 - np.linalg.norm(y_test - y_pred_lasso)**2 / np.linalg.norm(y_test)**2)
################################################################################
# ElasticNet
from scikits.learn.linear_model import ElasticNet
enet = ElasticNet(alpha=alpha, rho=0.7)
y_pred_enet = enet.fit(X_train, y_train).predict(X_test)
print enet
print "r^2 on test data : %f" % (
1 - np.linalg.norm(y_test - y_pred_enet)**2 / np.linalg.norm(y_test)**2)
X_train = X_train[idx]
y_train = y_train[idx]
std = X_train.std(axis=0)
mean = X_train.mean(axis=0)
X_train = (X_train - mean) / std
X_test = (X_test - mean) / std
std = y_train.std(axis=0)
mean = y_train.mean(axis=0)
y_train = (y_train - mean) / std
y_test = (y_test - mean) / std
gc.collect()
print "- benching ElasticNet"
clf = ElasticNet(alpha=alpha, rho=0.5, fit_intercept=False)
tstart = time()
clf.fit(X_train, y_train)
elnet_results[i, j, 0] = mean_square_error(clf.predict(X_test),
y_test)
elnet_results[i, j, 1] = time() - tstart
gc.collect()
print "- benching SGD"
n_iter = np.ceil(10**4.0 / n_train)
clf = SGDRegressor(alpha=alpha,
fit_intercept=False,
n_iter=n_iter,
learning_rate="invscaling",
eta0=.01,
power_t=0.25)
def fitRateSpectrum(Times, Data, Rates, w, Lnorm='ridge', standardizeData=True, CalcNdof=False, rho=0.5):
"""Using pseudo-inverse, with Tikhonov regularization (w parameter) to solve the inverse lapace tranform.
Returns coefficients A_k, residual sum of squares (rss), and number of degrees of freedom, for each relaxation rate.
"""
if Lnorm == 'lasso':
# Use L1-norm Lasso regression
try:
from scikits.learn.linear_model import Lasso
except:
print 'Error: could NOT import Lasso from scikits.learn.linear_model. Using L2 norm (ridge).'
Lnorm = 'ridge'
if Lnorm == 'enet':
# Use L1-L2-mixture norm Lasso regression
try:
from scikits.learn.linear_model import ElasticNet
except:
print 'Error: could NOT import ElasticNet from scikits.learn.linear_model. Using L2 norm (ridge).'
Lnorm = 'ridge'
if Lnorm == 'lasso':
lasso = Lasso(alpha = w, fit_intercept=False) # assume the data is already "centered" -- i.e. no zero rate
X, Xmean = Xsubmatrix(Rates, Times, standardizeData=standardizeData)
#print 'X.shape', X.shape, 'Data.shape', Data.shape
lasso.fit(X, Data, max_iter=1e6, tol=1e-7)
A = lasso.coef_
# Compute "residual sum of squares" (note loss function is different for L1-norm)
y_pred_lasso = lasso.predict(X)
diff = y_pred_lasso - Data
elif Lnorm == 'enet':
# NOTE: The convention for rho is backwards in scikits.learn, instead of rho we must send (1-rho)
enet = ElasticNet(alpha = w, rho=(1.-rho), fit_intercept=False) # assume the data is already "centered" -- i.e. no zero rate
X, Xmean = Xsubmatrix(Rates, Times, standardizeData=standardizeData)
#print 'X.shape', X.shape, 'Data.shape', Data.shape
#enet.fit(X, Data, max_iter=1e6, tol=1e-7)
enet.fit(X, Data, max_iter=1e6, tol=1e-3) # for testing
A = enet.coef_
# Compute "residual sum of squares" (note loss function is different for L1-norm)
y_pred_enet = enet.predict(X)
diff = y_pred_enet - Data
elif Lnorm == 'ridge':
X, Xmean = Xmatrix(Rates, Times, w, standardizeData=standardizeData )
Xinv = linalg.pinv(X)
y = np.array( Data.tolist() + [0. for k in Rates] )
if standardizeData:
y - y.mean()
A = np.dot(Xinv, y)
# Compute "residual sum of squares" (note loss function is different for L1-norm)
diff = SumSpectra(A, Rates, Times) - Data
rss = np.dot(diff,diff) # Residual sum of squares
if CalcNdof:
Xsub, Xmean = Xsubmatrix(Rates, Times, standardizeData=standardizeData)
XT = np.transpose(Xsub)
I_XT = np.eye(XT.shape[0])
I_X = np.eye(Xsub.shape[0])
Xtemp = np.dot(Xsub, np.linalg.inv(np.dot(XT,Xsub) + w*I_XT))
ndof = np.trace(I_X - np.dot(Xtemp,XT))
else:
ndof = None
return A, rss, ndof
