fix some test errors and warnings

Author: Anton Björklund

setup.cfg

@@ -1,12 +1,12 @@
 [metadata]
-name = SLISE
-version = 1.1.1
+name = slise
+version = 1.1.2
 author = Anton Björklund
 author_email = [email protected]
 description = The SLISE algorithm for robust regression and explanations of black box models
 long_description = file: README.md
 long_description_content_type = text/markdown
-url = https://github.com/edahelsini/pyslise
+url = https://github.com/edahelsinki/pyslise
 classifiers =
     Programming Language :: Python :: 3
     License :: OSI Approved :: MIT License

slise/optimisation.py

@@ -188,7 +188,7 @@ def p(x, g, fx, xnorm, gnorm, step, k, num_eval, *args):
             raise error
         else:
             warn(
-                "An optimisation step reaches the maximum number of iterations.",
+                "LBFGS optimisation reaches the maximum number of iterations.",
                 SliseWarning,
             )
     return x0

slise/plot.py

@@ -377,7 +377,10 @@ def fill_density(ax, X, x, n):
         if np.var(X) == 0:
             X = np.random.normal(X[0], 1e-8, len(X))
         kde1 = gaussian_kde(X, 0.2)
-        kde2 = gaussian_kde(X[subset], 0.2)
+        if np.any(subset):
+            kde2 = gaussian_kde(X[subset], 0.2)
+        else:
+            kde2 = lambda x: x * 0
         lim = extended_limits(X, 0.1, 100)
         ax.plot(lim, kde1(lim), color="black", label="Dataset")
         ax.plot(

tests/test_plot.py

@@ -9,17 +9,17 @@
 def test_plot2d():
     print("Testing 2D plots")
     X, Y, mod = data_create2(40, 1)
-    reg = regression(X, Y, 0.1, lambda1=0.01, lambda2=0.01, intercept=False)
+    reg = regression(X, Y, 0.1, lambda1=1e-4, lambda2=1e-4, intercept=False)
     reg.plot_2d(fig=plt.figure())
     reg = regression(
-        X, Y, 0.1, lambda1=0.01, lambda2=0.01, intercept=True, normalise=True
+        X, Y, 0.1, lambda1=1e-4, lambda2=1e-4, intercept=True, normalise=True
     )
     reg.plot_2d(fig=plt.figure())
-    exp = explain(X, Y, 0.1, 5, lambda1=0.01, lambda2=0.01)
+    exp = explain(X, Y, 0.1, 5, lambda1=1e-4, lambda2=1e-4)
     exp.plot_2d(fig=plt.figure())
     Y -= Y.min() - 0.01
     Y /= Y.max() + 0.01
-    exp = explain(X, Y, 1.0, 5, lambda1=0.01, lambda2=0.01, logit=True)
+    exp = explain(X, Y, 1.0, 5, lambda1=1e-4, lambda2=1e-4, logit=True)
     exp.plot_2d(fig=plt.figure())
     # plt.show()
     plt.close("all")
@@ -28,17 +28,17 @@ def test_plot2d():
 def test_dist():
     print("Testing dist plots")
     X, Y, mod = data_create2(40, 5)
-    reg = regression(X, Y, 0.1, lambda1=0.01, lambda2=0.01, intercept=False)
+    reg = regression(X, Y, 0.1, lambda1=1e-4, lambda2=1e-4, intercept=False)
     reg.plot_dist(fig=plt.figure())
     reg = regression(
-        X, Y, 0.1, lambda1=0.01, lambda2=0.01, intercept=True, normalise=True
+        X, Y, 0.1, lambda1=1e-4, lambda2=1e-4, intercept=True, normalise=True
     )
     reg.plot_dist(fig=plt.figure())
-    exp = explain(X, Y, 0.1, 5, lambda1=0.01, lambda2=0.01)
+    exp = explain(X, Y, 0.1, 5, lambda1=1e-4, lambda2=1e-4)
     exp.plot_dist(fig=plt.figure())
     Y = Y - Y.min() - 0.01
     Y /= Y.max() + 0.01
-    exp = explain(X, Y, 1.0, 5, lambda1=0.01, lambda2=0.01, normalise=True, logit=True)
+    exp = explain(X, Y, 1.0, 5, lambda1=1e-4, lambda2=1e-4, normalise=True, logit=True)
     exp.plot_dist(fig=plt.figure())
     reg.plot_subset(fig=plt.figure())
     exp.plot_subset(fig=plt.figure())
@@ -50,7 +50,7 @@ def test_img():
     print("Testing image plots")
     X, Y, mod = data_create2(200, 16)
     X[:, 6] = X[:, 9] = X[:, 11] = 0
-    exp = explain(X, Y, 0.1, 5, lambda1=0.01, lambda2=0.01)
+    exp = explain(X, Y, 0.1, 5, lambda1=1e-4, lambda2=1e-4)
     exp.plot_image(4, 4, fig=plt.figure())
     # plt.show()
     plt.close("all")

tests/test_slise.py

@@ -1,3 +1,4 @@
+from warnings import catch_warnings
 import numpy as np
 from slise.optimisation import loss_smooth
 from slise.data import add_intercept_column, scale_same
@@ -29,80 +30,82 @@ def test_initialise_old():
 
 
 def test_initialise():
-    print("Testing initialisation")
-    X, Y = data_create(20, 5)
-    zero = np.zeros(5)
-    alpha, beta = initialise_candidates(X, Y, 0.1)
-    assert beta > 0
-    assert loss_smooth(alpha, X, Y, 0.1, beta=beta) <= loss_smooth(
-        zero, X, Y, 0.1, beta=beta
-    )
-    X, Y = data_create(20, 12)
-    zero = np.zeros(12)
-    alpha, beta = initialise_candidates(X, Y, 0.1)
-    assert beta > 0
-    assert loss_smooth(alpha, X, Y, 0.1, beta=beta) <= loss_smooth(
-        zero, X, Y, 0.1, beta=beta
-    )
-    X, Y = data_create(20, 11)
-    X = add_intercept_column(X)
-    zero = np.zeros(12)
-    alpha, beta = initialise_candidates(X, Y, 0.1)
-    assert beta > 0
-    assert loss_smooth(alpha, X, Y, 0.1, beta=beta) <= loss_smooth(
-        zero, X, Y, 0.1, beta=beta
-    )
-    X, Y = data_create(20, 12)
-    x = np.random.normal(size=12)
-    X = X - x[None, :]
-    zero = np.zeros(12)
-    alpha, beta = initialise_candidates(X, Y, 0.1)
-    assert beta > 0
-    assert loss_smooth(alpha, X, Y, 0.1, beta=beta) <= loss_smooth(
-        zero, X, Y, 0.1, beta=beta
-    )
+    with catch_warnings(record=True) as w:
+        print("Testing initialisation")
+        X, Y = data_create(20, 5)
+        zero = np.zeros(5)
+        alpha, beta = initialise_candidates(X, Y, 0.1)
+        assert beta > 0
+        assert loss_smooth(alpha, X, Y, 0.1, beta=beta) <= loss_smooth(
+            zero, X, Y, 0.1, beta=beta
+        )
+        X, Y = data_create(20, 12)
+        zero = np.zeros(12)
+        alpha, beta = initialise_candidates(X, Y, 0.1)
+        assert beta > 0
+        assert loss_smooth(alpha, X, Y, 0.1, beta=beta) <= loss_smooth(
+            zero, X, Y, 0.1, beta=beta
+        )
+        X, Y = data_create(20, 11)
+        X = add_intercept_column(X)
+        zero = np.zeros(12)
+        alpha, beta = initialise_candidates(X, Y, 0.1)
+        assert beta > 0
+        assert loss_smooth(alpha, X, Y, 0.1, beta=beta) <= loss_smooth(
+            zero, X, Y, 0.1, beta=beta
+        )
+        X, Y = data_create(20, 12)
+        x = np.random.normal(size=12)
+        X = X - x[None, :]
+        zero = np.zeros(12)
+        alpha, beta = initialise_candidates(X, Y, 0.1)
+        assert beta > 0
+        assert loss_smooth(alpha, X, Y, 0.1, beta=beta) <= loss_smooth(
+            zero, X, Y, 0.1, beta=beta
+        )
 
 
 def test_initialise2():
-    print("Testing initialisation2")
-    X, Y = data_create(20, 5)
-    zero = np.zeros(5)
-    alpha, beta = initialise_candidates2(X, Y, 0.1)
-    assert beta > 0
-    assert loss_smooth(alpha, X, Y, 0.1, beta=beta) <= loss_smooth(
-        zero, X, Y, 0.1, beta=beta
-    )
-    X, Y = data_create(20, 12)
-    zero = np.zeros(12)
-    alpha, beta = initialise_candidates2(X, Y, 0.1)
-    assert beta > 0
-    assert loss_smooth(alpha, X, Y, 0.1, beta=beta) <= loss_smooth(
-        zero, X, Y, 0.1, beta=beta
-    )
-    X, Y = data_create(20, 11)
-    X = add_intercept_column(X)
-    zero = np.zeros(12)
-    alpha, beta = initialise_candidates2(X, Y, 0.1)
-    assert beta > 0
-    assert loss_smooth(alpha, X, Y, 0.1, beta=beta) <= loss_smooth(
-        zero, X, Y, 0.1, beta=beta
-    )
-    X, Y = data_create(20, 12)
-    x = np.random.normal(size=12)
-    X = X - x[None, :]
-    zero = np.zeros(12)
-    alpha, beta = initialise_candidates2(X, Y, 0.1)
-    assert beta > 0
-    assert loss_smooth(alpha, X, Y, 0.1, beta=beta) <= loss_smooth(
-        zero, X, Y, 0.1, beta=beta
-    )
+    with catch_warnings(record=True) as w:
+        print("Testing initialisation2")
+        X, Y = data_create(20, 5)
+        zero = np.zeros(5)
+        alpha, beta = initialise_candidates2(X, Y, 0.1)
+        assert beta > 0
+        assert loss_smooth(alpha, X, Y, 0.1, beta=beta) <= loss_smooth(
+            zero, X, Y, 0.1, beta=beta
+        )
+        X, Y = data_create(20, 12)
+        zero = np.zeros(12)
+        alpha, beta = initialise_candidates2(X, Y, 0.1)
+        assert beta > 0
+        assert loss_smooth(alpha, X, Y, 0.1, beta=beta) <= loss_smooth(
+            zero, X, Y, 0.1, beta=beta
+        )
+        X, Y = data_create(20, 11)
+        X = add_intercept_column(X)
+        zero = np.zeros(12)
+        alpha, beta = initialise_candidates2(X, Y, 0.1)
+        assert beta > 0
+        assert loss_smooth(alpha, X, Y, 0.1, beta=beta) <= loss_smooth(
+            zero, X, Y, 0.1, beta=beta
+        )
+        X, Y = data_create(20, 12)
+        x = np.random.normal(size=12)
+        X = X - x[None, :]
+        zero = np.zeros(12)
+        alpha, beta = initialise_candidates2(X, Y, 0.1)
+        assert beta > 0
+        assert loss_smooth(alpha, X, Y, 0.1, beta=beta) <= loss_smooth(
+            zero, X, Y, 0.1, beta=beta
+        )
 
 
 def test_slise_reg():
     print("Testing slise regression")
     X, Y, mod = data_create2(40, 5)
     reg1 = regression(
-        X, Y, epsilon=0.1, lambda1=0.01, lambda2=0.01, intercept=True, normalise=True,
+        X, Y, epsilon=0.1, lambda1=1e-4, lambda2=1e-4, intercept=True, normalise=True,
     )
     reg1.print()
     Yp = mat_mul_inter(X, reg1.coefficients)
@@ -119,7 +122,7 @@ def test_slise_reg():
     ), f"SLISE loss should be negative ({reg1.score():.2f}, {reg1.subset().mean():.2f})"
     assert 1.0 >= reg1.subset().mean() > 0.75
     reg2 = regression(
-        X, Y, epsilon=0.1, lambda1=0.01, lambda2=0.01, intercept=True, normalise=False,
+        X, Y, epsilon=0.1, lambda1=1e-4, lambda2=1e-4, intercept=True, normalise=False,
     )
     reg2.print()
     assert (
@@ -141,7 +144,7 @@ def test_slise_exp():
     X, Y, mod = data_create2(100, 5)
     x = np.random.normal(size=5)
     y = np.random.normal()
-    reg = explain(X, Y, 0.1, x, y, lambda1=0.01, lambda2=0.01, normalise=True)
+    reg = explain(X, Y, 0.1, x, y, lambda1=1e-4, lambda2=1e-4, normalise=True)
     reg.print()
     assert reg.score() <= 0, f"Slise loss should usually be <=0 ({reg.score():.2f})"
     assert 1.0 >= reg.subset().mean() > 0.0
@@ -153,11 +156,14 @@ def test_slise_exp():
     assert reg.score() <= 0, f"Slise loss should usually be <=0 ({reg.score():.2f})"
     assert 1.0 >= reg.subset().mean() > 0.0
     reg = explain(X, Y, 0.1, x, y, lambda1=0, lambda2=0, normalise=False)
+    reg.print()
     assert reg.score() <= 0, f"Slise loss should usually be <=0 ({reg.score():.2f})"
     assert 1.0 >= reg.subset().mean() > 0.0
     reg = explain(X, Y, 0.1, 19, lambda1=0.01, lambda2=0.01, normalise=False)
+    reg.print()
     assert reg.score() <= 0, f"Slise loss should usually be <=0 ({reg.score():.2f})"
     assert 1.0 >= reg.subset().mean() > 0.0
     reg = explain(X, Y, 0.1, 19, lambda1=0, lambda2=0, normalise=False)
+    reg.print()
     assert reg.score() <= 0, f"Slise loss should usually be <=0 ({reg.score():.2f})"
     assert 1.0 >= reg.subset().mean() > 0.0