def fit(self, X, y):
import statick.linear_model.bin.statick_linear_model as statick_linear_model
TMLR.fit(self, X, y)
func = ModelLogReg.CFUNC_RESOLVER(self, "_dao_")
object.__setattr__(self, "_dao",
getattr(statick_linear_model, func)(X, y))
return self
def _test_solver_astype_consistency(self, create_solver):
# Launch this test only once
if self.dtype != 'float64':
return
prox = ProxL2Sq(0.1)
use_intercept = True
y_64, X_64, coeffs0_64, interc0 = self.generate_logistic_data(
100, 30, 'float64', use_intercept)
model_64 = ModelLogReg(fit_intercept=use_intercept)
model_64.fit(X_64, y_64)
solver_64 = create_solver()
solver_64.set_model(model_64).set_prox(prox)
solution_64 = solver_64.solve()
solver_32 = solver_64.astype('float32')
solution_32 = solver_32.solve()
self.assertEqual(solution_64.dtype, 'float64')
self.assertEqual(solution_32.dtype, 'float32')
np.testing.assert_array_almost_equal(solution_32,
solution_64,
decimal=3)
def test_asaga_solver(self):
"""...Check ASAGA solver for a Logistic Regression with Elastic net
penalization
"""
seed = 1398
np.random.seed(seed)
n_samples = 4000
n_features = 30
weights = weights_sparse_gauss(n_features, nnz=3).astype(self.dtype)
intercept = 0.2
penalty_strength = 1e-3
sparsity = 1e-4
features = sparse.rand(n_samples, n_features, density=sparsity,
format='csr', random_state=8).astype(self.dtype)
simulator = SimuLogReg(weights, n_samples=n_samples, features=features,
verbose=False, intercept=intercept,
dtype=self.dtype)
features, labels = simulator.simulate()
model = ModelLogReg(fit_intercept=True)
model.fit(features, labels)
prox = ProxElasticNet(penalty_strength, ratio=0.1, range=(0,
n_features))
solver_step = 1. / model.get_lip_max()
saga = SAGA(step=solver_step, max_iter=100, tol=1e-10, verbose=False,
n_threads=1, record_every=10, seed=seed)
saga.set_model(model).set_prox(prox)
saga.solve()
asaga = SAGA(step=solver_step, max_iter=100, tol=1e-10, verbose=False,
n_threads=2, record_every=10, seed=seed)
asaga.set_model(model).set_prox(prox)
asaga.solve()
np.testing.assert_array_almost_equal(saga.solution, asaga.solution,
decimal=4)
self.assertGreater(np.linalg.norm(saga.solution[:-1]), 0)
n_samples = 40000
n_features = 20000
sparsity = 1e-4
penalty_strength = 1e-5
weights = weights_sparse_gauss(n_features, nnz=1000)
intercept = 0.2
features = sparse.rand(n_samples, n_features, density=sparsity, format='csr')
simulator = SimuLogReg(weights, n_samples=n_samples, features=features,
verbose=False, intercept=intercept)
features, labels = simulator.simulate()
model = ModelLogReg(fit_intercept=True)
model.fit(features, labels)
prox = ProxElasticNet(penalty_strength, ratio=0.5, range=(0, n_features))
svrg_step = 1. / model.get_lip_max()
test_n_threads = [1, 2, 4]
fig, axes = plt.subplots(1, 2, figsize=(8, 4))
for ax, SolverClass in zip(axes, [SVRG, SAGA]):
solver_list = []
solver_labels = []
for n_threads in test_n_threads:
solver = SolverClass(step=svrg_step, seed=seed, max_iter=50,
verbose=False, n_threads=n_threads, tol=0,
record_every=3)
