Refactor tests to use pytest features (#193)

* refactor tests to use pytest features

* run CI

* hotfix

* hotfix

* Update test_penalty.py

* Update test_sag.py

* Update test_sag.py

* Update test_sag.py

* address review comments

Author: StrikerRUS

lightning/impl/tests/conftest.py

@@ -0,0 +1,50 @@
+import pytest
+import scipy.sparse as sp
+
+from sklearn.datasets import load_iris
+
+from lightning.impl.datasets.samples_generator import make_classification
+
+
+@pytest.fixture(scope="module")
+def train_data():
+    iris = load_iris()
+    return iris.data, iris.target
+
+
+@pytest.fixture(scope="module")
+def bin_train_data(train_data):
+    X, y = train_data
+    X_bin = X[y <= 1]
+    y_bin = y[y <= 1] * 2 - 1
+    return X_bin, y_bin
+
+
+@pytest.fixture(scope="module")
+def bin_dense_train_data():
+    bin_dense, bin_target = make_classification(n_samples=200, n_features=100,
+                                                n_informative=5,
+                                                n_classes=2, random_state=0)
+    return bin_dense, bin_target
+
+
+@pytest.fixture(scope="module")
+def bin_sparse_train_data(bin_dense_train_data):
+    bin_dense, bin_target = bin_dense_train_data
+    bin_csr = sp.csr_matrix(bin_dense)
+    return bin_csr, bin_target
+
+
+@pytest.fixture(scope="module")
+def mult_dense_train_data():
+    mult_dense, mult_target = make_classification(n_samples=300, n_features=100,
+                                                  n_informative=5,
+                                                  n_classes=3, random_state=0)
+    return mult_dense, mult_target
+
+
+@pytest.fixture(scope="module")
+def mult_sparse_train_data(mult_dense_train_data):
+    mult_dense, mult_target = mult_dense_train_data
+    mult_sparse = sp.csr_matrix(mult_dense)
+    return mult_sparse, mult_target

lightning/impl/tests/test_adagrad.py

@@ -1,64 +1,63 @@
 import numpy as np
-
-from sklearn.datasets import load_iris
+import pytest
 
 from lightning.classification import AdaGradClassifier
 from lightning.regression import AdaGradRegressor
 from lightning.impl.adagrad_fast import _proj_elastic_all
 from lightning.impl.tests.utils import check_predict_proba
 
-iris = load_iris()
-X, y = iris.data, iris.target
-
-X_bin = X[y <= 1]
-y_bin = y[y <= 1] * 2 - 1
-
 
-def test_adagrad_elastic_hinge():
+def test_adagrad_elastic_hinge(bin_train_data):
+    X_bin, y_bin = bin_train_data
     clf = AdaGradClassifier(alpha=0.5, l1_ratio=0.85, n_iter=10, random_state=0)
     clf.fit(X_bin, y_bin)
     assert not hasattr(clf, "predict_proba")
     assert clf.score(X_bin, y_bin) == 1.0
 
 
-def test_adagrad_elastic_smooth_hinge():
+def test_adagrad_elastic_smooth_hinge(bin_train_data):
+    X_bin, y_bin = bin_train_data
     clf = AdaGradClassifier(alpha=0.5, l1_ratio=0.85, loss="smooth_hinge",
                             n_iter=10, random_state=0)
     clf.fit(X_bin, y_bin)
     assert not hasattr(clf, "predict_proba")
     assert clf.score(X_bin, y_bin) == 1.0
 
 
-def test_adagrad_elastic_log():
+def test_adagrad_elastic_log(bin_train_data):
+    X_bin, y_bin = bin_train_data
     clf = AdaGradClassifier(alpha=0.1, l1_ratio=0.85, loss="log", n_iter=10,
                             random_state=0)
     clf.fit(X_bin, y_bin)
     assert clf.score(X_bin, y_bin) == 1.0
     check_predict_proba(clf, X_bin)
 
 
-def test_adagrad_hinge_multiclass():
+def test_adagrad_hinge_multiclass(train_data):
+    X, y = train_data
     clf = AdaGradClassifier(alpha=1e-2, n_iter=100, loss="hinge", random_state=0)
     clf.fit(X, y)
     assert not hasattr(clf, "predict_proba")
     np.testing.assert_almost_equal(clf.score(X, y), 0.940, 3)
 
 
-def test_adagrad_classes_binary():
+def test_adagrad_classes_binary(bin_train_data):
+    X_bin, y_bin = bin_train_data
     clf = AdaGradClassifier()
     assert not hasattr(clf, 'classes_')
     clf.fit(X_bin, y_bin)
     assert list(clf.classes_) == [-1, 1]
 
 
-def test_adagrad_classes_multiclass():
+def test_adagrad_classes_multiclass(train_data):
+    X, y = train_data
     clf = AdaGradClassifier()
     assert not hasattr(clf, 'classes_')
     clf.fit(X, y)
     assert list(clf.classes_) == [0, 1, 2]
 
 
-def test_adagrad_callback():
+def test_adagrad_callback(bin_train_data):
     class Callback(object):
 
         def __init__(self, X, y):
@@ -74,16 +73,18 @@ def __call__(self, clf, t):
             score = clf.score(self.X, self.y)
             self.acc.append(score)
 
+    X_bin, y_bin = bin_train_data
     cb = Callback(X_bin, y_bin)
     clf = AdaGradClassifier(alpha=0.5, l1_ratio=0.85, n_iter=10,
                             callback=cb, random_state=0)
     clf.fit(X_bin, y_bin)
     assert cb.acc[-1] == 1.0
 
 
-def test_adagrad_regression():
-    for loss in ("squared", "absolute"):
-        reg = AdaGradRegressor(loss=loss)
-        reg.fit(X_bin, y_bin)
-        y_pred = np.sign(reg.predict(X_bin))
-        assert np.mean(y_bin == y_pred) == 1.0
+@pytest.mark.parametrize("loss", ["squared", "absolute"])
+def test_adagrad_regression(loss, bin_train_data):
+    X_bin, y_bin = bin_train_data
+    reg = AdaGradRegressor(loss=loss)
+    reg.fit(X_bin, y_bin)
+    y_pred = np.sign(reg.predict(X_bin))
+    assert np.mean(y_bin == y_pred) == 1.0

lightning/impl/tests/test_dataset.py

@@ -1,5 +1,7 @@
 import pickle
+
 import numpy as np
+import pytest
 import scipy.sparse as sp
 
 from sklearn.datasets import make_classification
@@ -10,26 +12,40 @@
 from lightning.impl.dataset_fast import CSRDataset
 from lightning.impl.dataset_fast import CSCDataset
 
-# Create test datasets.
-X, _ = make_classification(n_samples=20, n_features=100,
-                           n_informative=5, n_classes=2, random_state=0)
-X2, _ = make_classification(n_samples=10, n_features=100,
-                            n_informative=5, n_classes=2, random_state=0)
 
-# Sparsify datasets.
-X[X < 0.3] = 0
+@pytest.fixture(scope="module")
+def test_data():
+    X, _ = make_classification(n_samples=20, n_features=100,
+                               n_informative=5, n_classes=2, random_state=0)
+    X2, _ = make_classification(n_samples=10, n_features=100,
+                                n_informative=5, n_classes=2, random_state=0)
+
+    # Sparsify datasets.
+    X[X < 0.3] = 0
 
-X_csr = sp.csr_matrix(X)
-X_csc = sp.csc_matrix(X)
+    X_csr = sp.csr_matrix(X)
+    X_csc = sp.csc_matrix(X)
 
-rs = check_random_state(0)
-cds = ContiguousDataset(X)
-fds = FortranDataset(np.asfortranarray(X))
-csr_ds = CSRDataset(X_csr)
-csc_ds = CSCDataset(X_csc)
+    rs = check_random_state(0)
+    cds = ContiguousDataset(X)
+    fds = FortranDataset(np.asfortranarray(X))
+    csr_ds = CSRDataset(X_csr)
+    csc_ds = CSCDataset(X_csc)
 
+    return {
+        "X": X,
+        "X_csr": X_csr,
+        "X_csc": X_csc,
+        "contiguous_dataset": cds,
+        "fortran_dataset": fds,
+        "dataset_csr": csr_ds,
+        "dataset_csc": csc_ds
+    }
 
-def test_contiguous_get_row():
+
+def test_contiguous_get_row(test_data):
+    X = test_data["X"]
+    cds = test_data["contiguous_dataset"]
     ind = np.arange(X.shape[1])
     for i in range(X.shape[0]):
         indices, data, n_nz = cds.get_row(i)
@@ -38,15 +54,19 @@ def test_contiguous_get_row():
         assert n_nz == X.shape[1]
 
 
-def test_csr_get_row():
+def test_csr_get_row(test_data):
+    X = test_data["X"]
+    csr_ds = test_data["dataset_csr"]
     for i in range(X.shape[0]):
         indices, data, n_nz = csr_ds.get_row(i)
         for jj in range(n_nz):
             j = indices[jj]
             assert X[i, j] == data[jj]
 
 
-def test_fortran_get_column():
+def test_fortran_get_column(test_data):
+    X = test_data["X"]
+    fds = test_data["fortran_dataset"]
     ind = np.arange(X.shape[0])
     for j in range(X.shape[1]):
         indices, data, n_nz = fds.get_column(j)
@@ -55,18 +75,25 @@ def test_fortran_get_column():
         assert n_nz == X.shape[0]
 
 
-def test_csc_get_column():
+def test_csc_get_column(test_data):
+    X = test_data["X"]
+    csc_ds = test_data["dataset_csc"]
     for j in range(X.shape[1]):
         indices, data, n_nz = csc_ds.get_column(j)
         for ii in range(n_nz):
             i = indices[ii]
             assert X[i, j] == data[ii]
 
 
-def test_picklable_datasets():
-    """Test that the datasets are picklable."""
-
-    for dataset in [cds, csr_ds, fds, csc_ds]:
+def test_picklable_datasets(test_data):
+    # Test that the datasets are picklable.
+    X = test_data["X"]
+    for dataset in [
+        test_data["contiguous_dataset"],
+        test_data["dataset_csr"],
+        test_data["fortran_dataset"],
+        test_data["dataset_csc"]
+    ]:
         pds = pickle.dumps(dataset)
         dataset = pickle.loads(pds)
         assert dataset.get_n_samples() == X.shape[0]