MAINT Remove some unwanted side effects in our test suite (scikit-learn#29584)

Author: ogrisel

sklearn/gaussian_process/tests/test_kernels.py

@@ -37,6 +37,10 @@
 
 X = np.random.RandomState(0).normal(0, 1, (5, 2))
 Y = np.random.RandomState(0).normal(0, 1, (6, 2))
+# Set shared test data as read-only to avoid unintentional in-place
+# modifications that would introduce side-effects between tests.
+X.flags.writeable = False
+Y.flags.writeable = False
 
 kernel_rbf_plus_white = RBF(length_scale=2.0) + WhiteKernel(noise_level=3.0)
 kernels = [
@@ -70,6 +74,7 @@
 @pytest.mark.parametrize("kernel", kernels)
 def test_kernel_gradient(kernel):
     # Compare analytic and numeric gradient of kernels.
+    kernel = clone(kernel)  # make tests independent of one-another
     K, K_gradient = kernel(X, eval_gradient=True)
 
     assert K_gradient.shape[0] == X.shape[0]
@@ -97,6 +102,7 @@ def eval_kernel_for_theta(theta):
 )
 def test_kernel_theta(kernel):
     # Check that parameter vector theta of kernel is set correctly.
+    kernel = clone(kernel)  # make tests independent of one-another
     theta = kernel.theta
     _, K_gradient = kernel(X, eval_gradient=True)
 
@@ -154,6 +160,7 @@ def test_kernel_theta(kernel):
     ],
 )
 def test_auto_vs_cross(kernel):
+    kernel = clone(kernel)  # make tests independent of one-another
     # Auto-correlation and cross-correlation should be consistent.
     K_auto = kernel(X)
     K_cross = kernel(X, X)
@@ -162,6 +169,7 @@ def test_auto_vs_cross(kernel):
 
 @pytest.mark.parametrize("kernel", kernels)
 def test_kernel_diag(kernel):
+    kernel = clone(kernel)  # make tests independent of one-another
     # Test that diag method of kernel returns consistent results.
     K_call_diag = np.diag(kernel(X))
     K_diag = kernel.diag(X)
@@ -182,12 +190,12 @@ def test_kernel_anisotropic():
     kernel = 3.0 * RBF([0.5, 2.0])
 
     K = kernel(X)
-    X1 = np.array(X)
+    X1 = X.copy()
     X1[:, 0] *= 4
     K1 = 3.0 * RBF(2.0)(X1)
     assert_almost_equal(K, K1)
 
-    X2 = np.array(X)
+    X2 = X.copy()
     X2[:, 1] /= 4
     K2 = 3.0 * RBF(0.5)(X2)
     assert_almost_equal(K, K2)
@@ -202,13 +210,15 @@ def test_kernel_anisotropic():
     "kernel", [kernel for kernel in kernels if kernel.is_stationary()]
 )
 def test_kernel_stationary(kernel):
+    kernel = clone(kernel)  # make tests independent of one-another
     # Test stationarity of kernels.
     K = kernel(X, X + 1)
     assert_almost_equal(K[0, 0], np.diag(K))
 
 
 @pytest.mark.parametrize("kernel", kernels)
 def test_kernel_input_type(kernel):
+    kernel = clone(kernel)  # make tests independent of one-another
     # Test whether kernels is for vectors or structured data
     if isinstance(kernel, Exponentiation):
         assert kernel.requires_vector_input == kernel.kernel.requires_vector_input
@@ -237,6 +247,7 @@ def check_hyperparameters_equal(kernel1, kernel2):
 
 @pytest.mark.parametrize("kernel", kernels)
 def test_kernel_clone(kernel):
+    kernel = clone(kernel)  # make tests independent of one-another
     # Test that sklearn's clone works correctly on kernels.
     kernel_cloned = clone(kernel)
 
@@ -254,6 +265,7 @@ def test_kernel_clone(kernel):
 
 @pytest.mark.parametrize("kernel", kernels)
 def test_kernel_clone_after_set_params(kernel):
+    kernel = clone(kernel)  # make tests independent of one-another
     # This test is to verify that using set_params does not
     # break clone on kernels.
     # This used to break because in kernels such as the RBF, non-trivial
@@ -312,6 +324,7 @@ def test_matern_kernel():
 
 @pytest.mark.parametrize("kernel", kernels)
 def test_kernel_versus_pairwise(kernel):
+    kernel = clone(kernel)  # make tests independent of one-another
     # Check that GP kernels can also be used as pairwise kernels.
 
     # Test auto-kernel
@@ -330,6 +343,7 @@ def test_kernel_versus_pairwise(kernel):
 
 @pytest.mark.parametrize("kernel", kernels)
 def test_set_get_params(kernel):
+    kernel = clone(kernel)  # make tests independent of one-another
     # Check that set_params()/get_params() is consistent with kernel.theta.
 
     # Test get_params()
@@ -372,6 +386,7 @@ def test_set_get_params(kernel):
 
 @pytest.mark.parametrize("kernel", kernels)
 def test_repr_kernels(kernel):
+    kernel = clone(kernel)  # make tests independent of one-another
     # Smoke-test for repr in kernels.
 
     repr(kernel)

sklearn/metrics/_plot/tests/test_roc_curve_display.py

@@ -3,6 +3,7 @@
 from numpy.testing import assert_allclose
 from scipy.integrate import trapezoid
 
+from sklearn import clone
 from sklearn.compose import make_column_transformer
 from sklearn.datasets import load_breast_cancer, load_iris
 from sklearn.exceptions import NotFittedError
@@ -16,7 +17,11 @@
 
 @pytest.fixture(scope="module")
 def data():
-    return load_iris(return_X_y=True)
+    X, y = load_iris(return_X_y=True)
+    # Avoid introducing test dependencies by mistake.
+    X.flags.writeable = False
+    y.flags.writeable = False
+    return X, y
 
 
 @pytest.fixture(scope="module")
@@ -218,6 +223,8 @@ def test_roc_curve_display_complex_pipeline(pyplot, data_binary, clf, constructo
     """Check the behaviour with complex pipeline."""
     X, y = data_binary
 
+    clf = clone(clf)
+
     if constructor_name == "from_estimator":
         with pytest.raises(NotFittedError):
             RocCurveDisplay.from_estimator(clf, X, y)

sklearn/neighbors/tests/test_nca.py

@@ -22,11 +22,14 @@
 from sklearn.utils.validation import validate_data
 
 rng = check_random_state(0)
-# load and shuffle iris dataset
+# Load and shuffle the iris dataset.
 iris = load_iris()
 perm = rng.permutation(iris.target.size)
 iris_data = iris.data[perm]
 iris_target = iris.target[perm]
+# Avoid having test data introducing dependencies between tests.
+iris_data.flags.writeable = False
+iris_target.flags.writeable = False
 EPS = np.finfo(float).eps
 
 
@@ -414,8 +417,8 @@ def test_no_verbose(capsys):
 
 
 def test_singleton_class():
-    X = iris_data
-    y = iris_target
+    X = iris_data.copy()
+    y = iris_target.copy()
 
     # one singleton class
     singleton_class = 1

sklearn/tests/test_kernel_approximation.py

@@ -31,6 +31,11 @@
 X /= X.sum(axis=1)[:, np.newaxis]
 Y /= Y.sum(axis=1)[:, np.newaxis]
 
+# Make sure X and Y are not writable to avoid introducing dependencies between
+# tests.
+X.flags.writeable = False
+Y.flags.writeable = False
+
 
 @pytest.mark.parametrize("gamma", [0.1, 1, 2.5])
 @pytest.mark.parametrize("degree, n_components", [(1, 500), (2, 500), (3, 5000)])
@@ -95,8 +100,8 @@ def test_additive_chi2_sampler(csr_container):
 
     # compute exact kernel
     # abbreviations for easier formula
-    X_ = X[:, np.newaxis, :]
-    Y_ = Y[np.newaxis, :, :]
+    X_ = X[:, np.newaxis, :].copy()
+    Y_ = Y[np.newaxis, :, :].copy()
 
     large_kernel = 2 * X_ * Y_ / (X_ + Y_)
 
@@ -163,11 +168,12 @@ def test_skewed_chi2_sampler():
     # set on negative component but greater than c to ensure that the kernel
     # approximation is valid on the group (-c; +\infty) endowed with the skewed
     # multiplication.
-    Y[0, 0] = -c / 2.0
+    Y_ = Y.copy()
+    Y_[0, 0] = -c / 2.0
 
     # abbreviations for easier formula
     X_c = (X + c)[:, np.newaxis, :]
-    Y_c = (Y + c)[np.newaxis, :, :]
+    Y_c = (Y_ + c)[np.newaxis, :, :]
 
     # we do it in log-space in the hope that it's more stable
     # this array is n_samples_x x n_samples_y big x n_features
@@ -180,15 +186,15 @@ def test_skewed_chi2_sampler():
     # approximate kernel mapping
     transform = SkewedChi2Sampler(skewedness=c, n_components=1000, random_state=42)
     X_trans = transform.fit_transform(X)
-    Y_trans = transform.transform(Y)
+    Y_trans = transform.transform(Y_)
 
     kernel_approx = np.dot(X_trans, Y_trans.T)
     assert_array_almost_equal(kernel, kernel_approx, 1)
     assert np.isfinite(kernel).all(), "NaNs found in the Gram matrix"
     assert np.isfinite(kernel_approx).all(), "NaNs found in the approximate Gram matrix"
 
     # test error is raised on when inputs contains values smaller than -c
-    Y_neg = Y.copy()
+    Y_neg = Y_.copy()
     Y_neg[0, 0] = -c * 2.0
     msg = "X may not contain entries smaller than -skewedness"
     with pytest.raises(ValueError, match=msg):

sklearn/tests/test_pipeline.py

@@ -53,7 +53,13 @@
 from sklearn.utils.fixes import CSR_CONTAINERS
 from sklearn.utils.validation import _check_feature_names, check_is_fitted
 
+# Load a shared tests data sets for the tests in this module. Mark them
+# read-only to avoid unintentional in-place modifications that would introduce
+# side-effects between tests.
 iris = load_iris()
+iris.data.flags.writeable = False
+iris.target.flags.writeable = False
+
 
 JUNK_FOOD_DOCS = (
     "the pizza pizza beer copyright",
@@ -507,7 +513,7 @@ def test_predict_methods_with_predict_params(method_name):
 @pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
 def test_feature_union(csr_container):
     # basic sanity check for feature union
-    X = iris.data
+    X = iris.data.copy()
     X -= X.mean(axis=0)
     y = iris.target
     svd = TruncatedSVD(n_components=2, random_state=0)
@@ -1592,7 +1598,7 @@ def fit(self, X, y=None, **fit_params):
 def test_pipeline_missing_values_leniency():
     # check that pipeline let the missing values validation to
     # the underlying transformers and predictors.
-    X, y = iris.data, iris.target
+    X, y = iris.data.copy(), iris.target.copy()
     mask = np.random.choice([1, 0], X.shape, p=[0.1, 0.9]).astype(bool)
     X[mask] = np.nan
     pipe = make_pipeline(SimpleImputer(), LogisticRegression())

sklearn/tree/tests/test_tree.py

@@ -2686,7 +2686,8 @@ def test_regression_tree_missing_values_toy(Tree, X, criterion):
     tree = Tree(criterion=criterion, random_state=0).fit(X, y)
     tree_ref = clone(tree).fit(y.reshape(-1, 1), y)
 
-    assert all(tree.tree_.impurity >= 0)  # MSE should always be positive
+    impurity = tree.tree_.impurity
+    assert all(impurity >= 0), impurity.min()  # MSE should always be positive
 
     # Note: the impurity matches after the first split only on greedy trees
     if Tree is DecisionTreeRegressor: