def test_group_lasso():
"""Group Lasso test."""
n_samples, n_features = 100, 90
# assign group ids
groups = np.zeros(90)
groups[0:29] = 1
groups[30:59] = 2
groups[60:] = 3
# sample random coefficients
beta0 = np.random.normal(0.0, 1.0, 1)
beta = np.random.normal(0.0, 1.0, n_features)
beta[groups == 2] = 0.
# create an instance of the GLM class
glm_group = GLM(distr='softplus', alpha=1.)
# simulate training data
Xr = np.random.normal(0.0, 1.0, [n_samples, n_features])
yr = glm_group.simulate(beta0, beta, Xr)
# simulate testing data
Xt = np.random.normal(0.0, 1.0, [n_samples, n_features])
yt = glm_group.simulate(beta0, beta, Xt)
# scale and fit
scaler = StandardScaler().fit(Xr)
glm_group.fit(scaler.transform(Xr), yr)
def test_group_lasso():
"""Group Lasso test."""
n_samples, n_features = 100, 90
# assign group ids
groups = np.zeros(90)
groups[0:29] = 1
groups[30:59] = 2
groups[60:] = 3
# sample random coefficients
beta0 = np.random.normal(0.0, 1.0, 1)
beta = np.random.normal(0.0, 1.0, n_features)
beta[groups == 2] = 0.
# create an instance of the GLM class
glm_group = GLM(distr='softplus', alpha=1.)
# simulate training data
Xr = np.random.normal(0.0, 1.0, [n_samples, n_features])
yr = glm_group.simulate(beta0, beta, Xr)
# simulate testing data
Xt = np.random.normal(0.0, 1.0, [n_samples, n_features])
yt = glm_group.simulate(beta0, beta, Xt)
# scale and fit
scaler = StandardScaler().fit(Xr)
glm_group.fit(scaler.transform(Xr), yr)
def test_multinomial():
"""Test all multinomial functionality"""
glm_mn = GLM(distr='multinomial', reg_lambda=np.array([0.0, 0.1, 0.2]),
learning_rate = 2e-1, tol=1e-10)
X = np.array([[-1, -2, -3], [4, 5, 6]])
y = np.array([1, 0])
# test gradient
beta = np.zeros([4, 2])
grad_beta0, grad_beta = glm_mn._grad_L2loss(beta[0], beta[1:], 0, X, y)
assert_true(grad_beta0[0] != grad_beta0[1])
glm_mn.fit(X, y)
y_pred_proba = glm_mn.predict_proba(X)
assert_equal(y_pred_proba.shape, (3, X.shape[0], 2)) # n_lambdas x n_samples x n_classes
# pick one as yhat
yhat = y_pred_proba[0]
# uniform prediction
ynull = np.ones(yhat.shape) / yhat.shape[1]
# pseudo_R2 should be greater than 0
assert_true(glm_mn[-1].score(X, y) > 0.)
assert_equal(len(glm_mn.simulate(glm_mn.fit_[0]['beta0'],
glm_mn.fit_[0]['beta'],
X)),
X.shape[0])
# check that score is computed for sliced estimator
scorelist = glm_mn[-1].score(X, y)
assert_equal(scorelist.shape[0], 1)
# check that score is computed for all lambdas
scorelist = glm_mn.score(X, y)
assert_equal(scorelist.shape[0], y_pred_proba.shape[0])
def test_multinomial():
"""Test all multinomial functionality"""
glm_mn = GLM(distr='multinomial',
reg_lambda=np.array([0.0, 0.1, 0.2]),
learning_rate=2e-1,
tol=1e-10)
X = np.array([[-1, -2, -3], [4, 5, 6]])
y = np.array([1, 0])
# test gradient
beta = np.zeros([4, 2])
grad_beta0, grad_beta = glm_mn._grad_L2loss(beta[0], beta[1:], 0, X, y)
assert_true(grad_beta0[0] != grad_beta0[1])
glm_mn.fit(X, y)
y_pred = glm_mn.predict(X)
assert_equal(y_pred.shape,
(3, X.shape[0], 2)) # n_lambdas x n_samples x n_classes
# pick one as yhat
yhat = y_pred[0]
# uniform prediction
ynull = np.ones(yhat.shape) / yhat.shape[1]
# pseudo_R2 should be greater than 0
assert_true(glm_mn.score(y, yhat, ynull, method='pseudo_R2') > 0.)
glm_mn.score(y, yhat)
assert_equal(
len(glm_mn.simulate(glm_mn.fit_[0]['beta0'], glm_mn.fit_[0]['beta'],
X)), X.shape[0])
# these should raise an exception
assert_raises(ValueError, glm_mn.score, y, y, y, 'pseudo_R2')
assert_raises(ValueError, glm_mn.score, y, y, None, 'deviance')
def test_multinomial():
"""Test all multinomial functionality"""
glm_mn = GLM(distr='multinomial', reg_lambda=np.array([0.0, 0.1, 0.2]),
learning_rate = 2e-1, tol=1e-10)
X = np.array([[-1, -2, -3], [4, 5, 6]])
y = np.array([1, 0])
# test gradient
beta = np.zeros([4, 2])
grad_beta0, grad_beta = glm_mn._grad_L2loss(beta[0], beta[1:], 0, X, y)
assert_true(grad_beta0[0] != grad_beta0[1])
glm_mn.fit(X, y)
y_pred = glm_mn.predict(X)
assert_equal(y_pred.shape, (3, X.shape[0], 2)) # n_lambdas x n_samples x n_classes
# pick one as yhat
yhat = y_pred[0]
# uniform prediction
ynull = np.ones(yhat.shape) / yhat.shape[1]
# pseudo_R2 should be greater than 0
assert_true(glm_mn.score(y, yhat, ynull, method='pseudo_R2') > 0.)
glm_mn.score(y, yhat)
assert_equal(len(glm_mn.simulate(glm_mn.fit_[0]['beta0'],
glm_mn.fit_[0]['beta'],
X)),
X.shape[0])
# these should raise an exception
assert_raises(ValueError, glm_mn.score, y, y, y, 'pseudo_R2')
assert_raises(ValueError, glm_mn.score, y, y, None, 'deviance')
def test_multinomial():
"""Test all multinomial functionality"""
glm = GLM(distr='multinomial', reg_lambda=np.array([0.0, 0.1, 0.2]), tol=1e-10)
X = np.array([[-1, -2, -3], [4, 5, 6]])
y = np.array([1, 0])
# test gradient
beta = np.zeros([4, 2])
grad_beta0, grad_beta = glm.grad_L2loss(beta[0], beta[1:], 0, X, y)
assert grad_beta0[0] != grad_beta0[1]
glm.fit(X, y)
y_pred = glm.predict(X)
assert_equal(y_pred.shape, (3, X.shape[0], 2)) # n_lambdas x n_samples x n_classes
# pick one as yhat
yhat = y_pred[0]
# uniform prediction
ynull = np.ones(yhat.shape) / yhat.shape[1]
# pseudo_R2 should be greater than 0
assert_true(glm.pseudo_R2(y, yhat, ynull) > 0.)
glm.deviance(y, yhat)
assert_equal(len(glm.simulate(glm.fit_[0]['beta0'],
glm.fit_[0]['beta'],
X)),
X.shape[0])
# these should raise an exception
try:
glm.pseudo_R2(y, y, y)
assert False
except Exception:
assert True
try:
glm.deviance(y, y)
assert False
except Exception:
assert True
def test_glmnet():
"""Test glmnet."""
scaler = StandardScaler()
n_samples, n_features = 1000, 100
density = 0.1
n_lambda = 10
# coefficients
beta0 = 1. / (np.float(n_features) + 1.) * \
np.random.normal(0.0, 1.0)
beta = 1. / (np.float(n_features) + 1.) * \
np.random.normal(0.0, 1.0, [n_features, 1])
distrs = ['softplus', 'poisson', 'gaussian', 'binomial']
solvers = ['batch-gradient', 'cdfast']
score_metric = 'pseudo_R2'
learning_rate = 2e-1
for solver in solvers:
for distr in distrs:
glm = GLM(distr, learning_rate=learning_rate,
solver=solver, score_metric=score_metric)
assert_true(repr(glm))
np.random.seed(glm.random_state)
X_train = np.random.normal(0.0, 1.0, [n_samples, n_features])
y_train = glm.simulate(beta0, beta, X_train)
X_train = scaler.fit_transform(X_train)
glm.fit(X_train, y_train)
beta_ = glm.fit_[-1]['beta'][:]
assert_allclose(beta[:], beta_, atol=0.5) # check fit
y_pred = glm.predict(scaler.transform(X_train))
assert_equal(y_pred.shape, (n_lambda, X_train.shape[0]))
# checks for slicing.
glm = glm[:3]
glm_copy = glm.copy()
assert_true(glm_copy is not glm)
assert_equal(len(glm.reg_lambda), 3)
y_pred = glm[:2].predict(scaler.transform(X_train))
assert_equal(y_pred.shape, (2, X_train.shape[0]))
y_pred = glm[2].predict(scaler.transform(X_train))
assert_equal(y_pred.shape, (X_train.shape[0], ))
assert_raises(IndexError, glm.__getitem__, [2])
glm.score(X_train, y_train)
# don't allow slicing if model has not been fit yet.
glm_poisson = GLM(distr='softplus')
assert_raises(ValueError, glm_poisson.__getitem__, 2)
# test fit_predict
glm_poisson.fit_predict(X_train, y_train)
assert_raises(ValueError, glm_poisson.fit_predict, X_train[None, ...], y_train)
def test_glmnet():
"""Test glmnet."""
scaler = StandardScaler()
n_samples, n_features = 1000, 100
density = 0.1
n_lambda = 10
# coefficients
beta0 = 1. / (np.float(n_features) + 1.) * \
np.random.normal(0.0, 1.0)
beta = 1. / (np.float(n_features) + 1.) * \
np.random.normal(0.0, 1.0, [n_features, 1])
distrs = ['poisson', 'poissonexp', 'normal', 'binomial']
solvers = ['batch-gradient', 'cdfast']
learning_rate = 2e-1
for solver in solvers:
for distr in distrs:
glm = GLM(distr, learning_rate=learning_rate, solver=solver)
assert_true(repr(glm))
np.random.seed(glm.random_state)
X_train = np.random.normal(0.0, 1.0, [n_samples, n_features])
y_train = glm.simulate(beta0, beta, X_train)
X_train = scaler.fit_transform(X_train)
glm.fit(X_train, y_train)
beta_ = glm.fit_[-1]['beta'][:]
assert_allclose(beta[:], beta_, atol=0.5) # check fit
y_pred = glm.predict(scaler.transform(X_train))
assert_equal(y_pred.shape, (n_lambda, X_train.shape[0]))
# checks for slicing.
glm = glm[:3]
glm_copy = glm.copy()
assert_true(glm_copy is not glm)
assert_equal(len(glm.reg_lambda), 3)
y_pred = glm[:2].predict(scaler.transform(X_train))
assert_equal(y_pred.shape, (2, X_train.shape[0]))
y_pred = glm[2].predict(scaler.transform(X_train))
assert_equal(y_pred.shape, (X_train.shape[0], ))
assert_raises(IndexError, glm.__getitem__, [2])
glm.score(y_train, y_pred)
# don't allow slicing if model has not been fit yet.
glm_poisson = GLM(distr='poisson')
assert_raises(ValueError, glm_poisson.__getitem__, 2)
# test fit_predict
glm_poisson.fit_predict(X_train, y_train)
assert_raises(ValueError, glm_poisson.fit_predict, X_train[None, ...],
y_train)
def test_glmnet():
"""Test glmnet."""
scaler = StandardScaler()
n_samples, n_features = 10000, 100
density = 0.1
n_lambda = 10
# coefficients
beta0 = np.random.rand()
beta = sps.rand(n_features, 1, density=density).toarray()
distrs = ['poisson', 'poissonexp', 'normal', 'binomial']
for distr in distrs:
# FIXME: why do we need such this learning rate for 'poissonexp'?
learning_rate = 1e-5 if distr == 'poissonexp' else 1e-4
glm = GLM(distr, learning_rate=learning_rate)
assert_true(repr(glm))
np.random.seed(glm.random_state)
X_train = np.random.normal(0.0, 1.0, [n_samples, n_features])
y_train = glm.simulate(beta0, beta, X_train)
X_train = scaler.fit_transform(X_train)
glm.fit(X_train, y_train)
beta_ = glm.fit_[-2]['beta'][:]
assert_allclose(beta[:], beta_, atol=0.1) # check fit
density_ = np.sum(beta_ > 0.1) / float(n_features)
assert_allclose(density_, density, atol=0.05) # check density
y_pred = glm.predict(scaler.transform(X_train))
assert_equal(y_pred.shape, (n_lambda, X_train.shape[0]))
# checks for slicing.
glm = glm[:3]
glm_copy = glm.copy()
assert_true(glm_copy is not glm)
assert_equal(len(glm.reg_lambda), 3)
y_pred = glm[:2].predict(scaler.transform(X_train))
assert_equal(y_pred.shape, (2, X_train.shape[0]))
y_pred = glm[2].predict(scaler.transform(X_train))
assert_equal(y_pred.shape, (X_train.shape[0], ))
assert_raises(IndexError, glm.__getitem__, [2])
glm.deviance(y_train, y_pred)
# don't allow slicing if model has not been fit yet.
glm = GLM(distr='poisson')
assert_raises(ValueError, glm.__getitem__, 2)
# test fit_predict
glm.fit_predict(X_train, y_train)
assert_raises(ValueError, glm.fit_predict, X_train[None, ...], y_train)
def test_glmnet():
"""Test glmnet."""
glm = GLM(distr='poisson')
scaler = StandardScaler()
n_samples, n_features = 10000, 100
density = 0.1
# coefficients
beta0 = np.random.rand()
beta = sps.rand(n_features, 1, density=density).toarray()
X_train = np.random.normal(0.0, 1.0, [n_samples, n_features])
y_train = glm.simulate(beta0, beta, X_train)
X_train = scaler.fit_transform(X_train)
glm.fit(X_train, y_train)
beta_ = glm.fit_params[-2]['beta'][:]
assert_allclose(beta[:], beta_, atol=0.1) # check fit
density_ = np.sum(beta_ > 0.1) / float(n_features)
assert_allclose(density_, density, atol=0.02) # check density
def test_multinomial():
"""Test all multinomial functionality"""
glm_mn = GLM(distr='multinomial',
reg_lambda=np.array([0.0, 0.1, 0.2]),
learning_rate=2e-1,
tol=1e-10)
X = np.array([[-1, -2, -3], [4, 5, 6]])
y = np.array([1, 0])
# test gradient
beta = np.zeros([4, 2])
grad_beta0, grad_beta = glm_mn._grad_L2loss(beta[0], beta[1:], 0, X, y)
assert_true(grad_beta0[0] != grad_beta0[1])
glm_mn.fit(X, y)
y_pred_proba = glm_mn.predict_proba(X)
assert_equal(y_pred_proba.shape,
(3, X.shape[0], 2)) # n_lambdas x n_samples x n_classes
# pick one as yhat
yhat = y_pred_proba[0]
# uniform prediction
ynull = np.ones(yhat.shape) / yhat.shape[1]
# pseudo_R2 should be greater than 0
assert_true(glm_mn[-1].score(X, y) > 0.)
assert_equal(
len(glm_mn.simulate(glm_mn.fit_[0]['beta0'], glm_mn.fit_[0]['beta'],
X)), X.shape[0])
# check that score is computed for sliced estimator
scorelist = glm_mn[-1].score(X, y)
assert_equal(scorelist.shape[0], 1)
# check that score is computed for all lambdas
scorelist = glm_mn.score(X, y)
assert_equal(scorelist.shape[0], y_pred_proba.shape[0])
# parameters, or provided by the user, ``simulate()`` requires # only the independent variables ``X`` and the coefficients ``beta0`` # and ``beta`` ########################################################## n_samples, n_features = 10000, 100 # coefficients beta0 = np.random.normal(0.0, 1.0, 1) beta = sps.rand(n_features, 1, 0.1) beta = np.array(beta.todense()) # training data Xr = np.random.normal(0.0, 1.0, [n_samples, n_features]) yr = glm_poisson.simulate(beta0, beta, Xr) # testing data Xt = np.random.normal(0.0, 1.0, [n_samples, n_features]) yt = glm_poisson.simulate(beta0, beta, Xt) ########################################################## # Fit the model # ^^^^^^^^^^^^^ # Fitting the model is accomplished by a single GLM method called `fit()`. ########################################################## scaler = StandardScaler().fit(Xr) glm_poisson.fit(scaler.transform(Xr), yr)
######################################################## ######################################################## # Dataset size n_samples, n_features = 10000, 100 # baseline term beta0 = np.random.normal(0.0, 1.0, 1) # sparse model terms beta = sps.rand(n_features, 1, 0.1) beta = np.array(beta.todense()) # training data Xr = np.random.normal(0.0, 1.0, [n_samples, n_features]) yr = glm_poissonexp.simulate(beta0, beta, Xr) # testing data Xt = np.random.normal(0.0, 1.0, [n_samples, n_features]) yt = glm_poissonexp.simulate(beta0, beta, Xt) ######################################################## # Fit model to training data ######################################################## scaler = StandardScaler().fit(Xr) glm_poissonexp.fit(scaler.transform(Xr), yr) ######################################################## # Gradient of loss function
def test_cdfast():
"""Test all functionality related to fast coordinate descent"""
scaler = StandardScaler()
n_samples = 1000
n_features = 100
n_classes = 5
density = 0.1
distrs = ['softplus', 'poisson', 'gaussian', 'binomial', 'multinomial']
for distr in distrs:
glm = GLM(distr, solver='cdfast')
np.random.seed(glm.random_state)
if distr != 'multinomial':
# coefficients
beta0 = np.random.rand()
beta = sps.rand(n_features, 1, density=density).toarray()
# data
X = np.random.normal(0.0, 1.0, [n_samples, n_features])
X = scaler.fit_transform(X)
y = glm.simulate(beta0, beta, X)
elif distr == 'multinomial':
# coefficients
beta0 = 1 / (n_features + 1) * \
np.random.normal(0.0, 1.0, n_classes)
beta = 1 / (n_features + 1) * \
np.random.normal(0.0, 1.0, [n_features, n_classes])
# data
X, y = make_classification(n_samples=n_samples,
n_features=n_features,
n_redundant=0,
n_informative=n_features,
random_state=1,
n_classes=n_classes)
y_bk = y.ravel()
y = np.zeros([X.shape[0], y.max() + 1])
y[np.arange(X.shape[0]), y_bk] = 1
# compute grad and hess
beta_ = np.zeros([n_features + 1, beta.shape[1]])
beta_[0] = beta0
beta_[1:] = beta
z = beta_[0] + np.dot(X, beta_[1:])
k = 1
xk = np.expand_dims(X[:, k - 1], axis=1)
gk, hk = glm._gradhess_logloss_1d(xk, y, z)
# test grad and hess
if distr != 'multinomial':
assert_equal(np.size(gk), 1)
assert_equal(np.size(hk), 1)
assert_true(isinstance(gk, float))
assert_true(isinstance(hk, float))
else:
assert_equal(gk.shape[0], n_classes)
assert_equal(hk.shape[0], n_classes)
assert_true(isinstance(gk, np.ndarray))
assert_true(isinstance(hk, np.ndarray))
assert_equal(gk.ndim, 1)
assert_equal(hk.ndim, 1)
# test cdfast
ActiveSet = np.ones(n_features + 1)
rl = glm.reg_lambda[0]
beta_ret, z_ret = glm._cdfast(X, y, z, ActiveSet, beta_, rl)
assert_equal(beta_ret.shape, beta_.shape)
assert_equal(z_ret.shape, z.shape)
def test_tikhonov():
"""Tikhonov regularization test"""
n_samples, n_features = 1000, 100
# design covariance matrix of parameters
Gam = 15.
PriorCov = np.zeros([n_features, n_features])
for i in np.arange(0, n_features):
for j in np.arange(i, n_features):
PriorCov[i, j] = np.exp(-Gam * 1./ (np.float(n_features) ** 2) * \
(np.float(i) - np.float(j)) ** 2)
PriorCov[j, i] = PriorCov[i, j]
if i == j:
PriorCov[i, j] += 0.01
PriorCov = 1. / np.max(PriorCov) * PriorCov
# sample parameters as multivariate normal
beta0 = np.random.randn()
beta = np.random.multivariate_normal(np.zeros(n_features), PriorCov)
# sample train and test data
glm_sim = GLM(distr='softplus', score_metric='pseudo_R2')
X = np.random.randn(n_samples, n_features)
y = glm_sim.simulate(beta0, beta, X)
from sklearn.cross_validation import train_test_split
Xtrain, Xtest, ytrain, ytest = \
train_test_split(X, y, test_size=0.5, random_state=42)
# design tikhonov matrix
[U, S, V] = np.linalg.svd(PriorCov, full_matrices=False)
Tau = np.dot(np.diag(1. / np.sqrt(S)), U)
Tau = 1. / np.sqrt(np.float(n_samples)) * Tau / Tau.max()
# fit model with batch gradient
glm_tikhonov = GLM(distr='softplus',
alpha=0.0,
Tau=Tau,
solver='batch-gradient',
tol=1e-5,
score_metric='pseudo_R2')
glm_tikhonov.fit(Xtrain, ytrain)
ytrain_hat = glm_tikhonov[-1].predict(Xtrain)
ytest_hat = glm_tikhonov[-1].predict(Xtest)
R2_train = dict()
R2_test = dict()
R2_train['tikhonov'] = glm_tikhonov[-1].score(Xtrain, ytrain)
R2_test['tikhonov'] = glm_tikhonov[-1].score(Xtest, ytest)
# fit model with cdfast
glm_tikhonov = GLM(distr='softplus',
alpha=0.0,
Tau=Tau,
solver='cdfast',
tol=1e-5,
score_metric='pseudo_R2')
glm_tikhonov.fit(Xtrain, ytrain)
ytrain_hat = glm_tikhonov[-1].predict(Xtrain)
ytest_hat = glm_tikhonov[-1].predict(Xtest)
R2_train = dict()
R2_test = dict()
R2_train['tikhonov'] = glm_tikhonov[-1].score(Xtrain, ytrain)
R2_test['tikhonov'] = glm_tikhonov[-1].score(Xtest, ytest)
def test_tikhonov():
"""Tikhonov regularization test"""
n_samples, n_features = 1000, 100
# design covariance matrix of parameters
Gam = 15.
PriorCov = np.zeros([n_features, n_features])
for i in np.arange(0, n_features):
for j in np.arange(i, n_features):
PriorCov[i, j] = np.exp(-Gam * 1./ (np.float(n_features) ** 2) * \
(np.float(i) - np.float(j)) ** 2)
PriorCov[j, i] = PriorCov[i, j]
if i == j:
PriorCov[i, j] += 0.01
PriorCov = 1./ np.max(PriorCov) * PriorCov
# sample parameters as multivariate normal
beta0 = np.random.randn()
beta = np.random.multivariate_normal(np.zeros(n_features), PriorCov)
# sample train and test data
glm_sim = GLM(distr='softplus', score_metric='pseudo_R2')
X = np.random.randn(n_samples, n_features)
y = glm_sim.simulate(beta0, beta, X)
from sklearn.cross_validation import train_test_split
Xtrain, Xtest, ytrain, ytest = \
train_test_split(X, y, test_size=0.5, random_state=42)
# design tikhonov matrix
[U, S, V] = np.linalg.svd(PriorCov, full_matrices=False)
Tau = np.dot(np.diag(1. / np.sqrt(S)), U)
Tau = 1. / np.sqrt(np.float(n_samples)) * Tau / Tau.max()
# fit model with batch gradient
glm_tikhonov = GLM(distr='softplus',
alpha=0.0,
Tau=Tau,
solver='batch-gradient',
tol=1e-5,
score_metric='pseudo_R2')
glm_tikhonov.fit(Xtrain, ytrain);
ytrain_hat = glm_tikhonov[-1].predict(Xtrain)
ytest_hat = glm_tikhonov[-1].predict(Xtest)
R2_train = dict()
R2_test = dict()
R2_train['tikhonov'] = glm_tikhonov[-1].score(Xtrain, ytrain)
R2_test['tikhonov'] = glm_tikhonov[-1].score(Xtest, ytest)
# fit model with cdfast
glm_tikhonov = GLM(distr='softplus',
alpha=0.0,
Tau=Tau,
solver='cdfast',
tol=1e-5,
score_metric='pseudo_R2')
glm_tikhonov.fit(Xtrain, ytrain)
ytrain_hat = glm_tikhonov[-1].predict(Xtrain)
ytest_hat = glm_tikhonov[-1].predict(Xtest)
R2_train = dict()
R2_test = dict()
R2_train['tikhonov'] = glm_tikhonov[-1].score(Xtrain, ytrain)
R2_test['tikhonov'] = glm_tikhonov[-1].score(Xtest, ytest)
def test_cdfast():
"""Test all functionality related to fast coordinate descent"""
scaler = StandardScaler()
n_samples = 1000
n_features = 100
n_classes = 5
density = 0.1
distrs = ['softplus', 'poisson', 'gaussian', 'binomial', 'multinomial']
for distr in distrs:
glm = GLM(distr, solver='cdfast')
np.random.seed(glm.random_state)
if distr != 'multinomial':
# coefficients
beta0 = np.random.rand()
beta = sps.rand(n_features, 1, density=density).toarray()
# data
X = np.random.normal(0.0, 1.0, [n_samples, n_features])
X = scaler.fit_transform(X)
y = glm.simulate(beta0, beta, X)
elif distr == 'multinomial':
# coefficients
beta0 = 1 / (n_features + 1) * \
np.random.normal(0.0, 1.0, n_classes)
beta = 1 / (n_features + 1) * \
np.random.normal(0.0, 1.0, [n_features, n_classes])
# data
X, y = make_classification(n_samples=n_samples,
n_features=n_features,
n_redundant=0,
n_informative=n_features,
random_state=1, n_classes=n_classes)
y_bk = y.ravel()
y = np.zeros([X.shape[0], y.max() + 1])
y[np.arange(X.shape[0]), y_bk] = 1
# compute grad and hess
beta_ = np.zeros([n_features+1, beta.shape[1]])
beta_[0] = beta0
beta_[1:] = beta
z = beta_[0] + np.dot(X, beta_[1:])
k = 1
xk = np.expand_dims(X[:, k - 1], axis=1)
gk, hk = glm._gradhess_logloss_1d(xk, y, z)
# test grad and hess
if distr != 'multinomial':
assert_equal(np.size(gk), 1)
assert_equal(np.size(hk), 1)
assert_true(isinstance(gk, float))
assert_true(isinstance(hk, float))
else:
assert_equal(gk.shape[0], n_classes)
assert_equal(hk.shape[0], n_classes)
assert_true(isinstance(gk, np.ndarray))
assert_true(isinstance(hk, np.ndarray))
assert_equal(gk.ndim, 1)
assert_equal(hk.ndim, 1)
# test cdfast
ActiveSet = np.ones(n_features + 1)
rl = glm.reg_lambda[0]
beta_ret, z_ret = glm._cdfast(X, y, z, ActiveSet, beta_, rl)
assert_equal(beta_ret.shape, beta_.shape)
assert_equal(z_ret.shape, z.shape)
