From 604dacab92f203de84755500c16646eb2e2a4311 Mon Sep 17 00:00:00 2001 From: giorgiop Date: Wed, 4 Nov 2015 09:49:34 +0100 Subject: [PATCH 1/8] test_gpc --- sklearn/gaussian_process/tests/test_gpc.py | 29 ++++++++++++---------- 1 file changed, 16 insertions(+), 13 deletions(-) diff --git a/sklearn/gaussian_process/tests/test_gpc.py b/sklearn/gaussian_process/tests/test_gpc.py index 3cc1a2ea429e3..301379a125bb6 100644 --- a/sklearn/gaussian_process/tests/test_gpc.py +++ b/sklearn/gaussian_process/tests/test_gpc.py @@ -10,7 +10,7 @@ from sklearn.gaussian_process import GaussianProcessClassifier from sklearn.gaussian_process.kernels import RBF, ConstantKernel as C -from sklearn.utils.testing import (assert_true, assert_greater, assert_equal, +from sklearn.utils.testing import (assert_true, assert_greater, assert_almost_equal, assert_array_equal) @@ -29,8 +29,8 @@ def f(x): fixed_kernel = RBF(length_scale=1.0, length_scale_bounds="fixed") kernels = [RBF(length_scale=0.1), fixed_kernel, RBF(length_scale=1.0, length_scale_bounds=(1e-3, 1e3)), - C(1.0, (1e-2, 1e2)) - * RBF(length_scale=1.0, length_scale_bounds=(1e-3, 1e3))] + C(1.0, (1e-2, 1e2)) * + RBF(length_scale=1.0, length_scale_bounds=(1e-3, 1e3))] def test_predict_consistent(): @@ -45,7 +45,8 @@ def test_predict_consistent(): def test_lml_improving(): """ Test that hyperparameter-tuning improves log-marginal likelihood. """ for kernel in kernels: - if kernel == fixed_kernel: continue + if kernel == fixed_kernel: + continue gpc = GaussianProcessClassifier(kernel=kernel).fit(X, y) assert_greater(gpc.log_marginal_likelihood(gpc.kernel_.theta), gpc.log_marginal_likelihood(kernel.theta)) @@ -62,15 +63,16 @@ def test_lml_precomputed(): def test_converged_to_local_maximum(): """ Test that we are in local maximum after hyperparameter-optimization.""" for kernel in kernels: - if kernel == fixed_kernel: continue + if kernel == fixed_kernel: + continue gpc = GaussianProcessClassifier(kernel=kernel).fit(X, y) lml, lml_gradient = \ gpc.log_marginal_likelihood(gpc.kernel_.theta, True) - assert_true(np.all((np.abs(lml_gradient) < 1e-4) - | (gpc.kernel_.theta == gpc.kernel_.bounds[:, 0]) - | (gpc.kernel_.theta == gpc.kernel_.bounds[:, 1]))) + assert_true(np.all((np.abs(lml_gradient) < 1e-4) | + (gpc.kernel_.theta == gpc.kernel_.bounds[:, 0]) | + (gpc.kernel_.theta == gpc.kernel_.bounds[:, 1]))) def test_lml_gradient(): @@ -93,7 +95,7 @@ def test_random_starts(): Test that an increasing number of random-starts of GP fitting only increases the log marginal likelihood of the chosen theta. """ - n_samples, n_features = 25, 3 + n_samples, n_features = 25, 2 np.random.seed(0) rng = np.random.RandomState(0) X = rng.randn(n_samples, n_features) * 2 - 1 @@ -103,7 +105,7 @@ def test_random_starts(): * RBF(length_scale=[1e-3] * n_features, length_scale_bounds=[(1e-4, 1e+2)] * n_features) last_lml = -np.inf - for n_restarts_optimizer in range(9): + for n_restarts_optimizer in range(5): gp = GaussianProcessClassifier( kernel=kernel, n_restarts_optimizer=n_restarts_optimizer, random_state=0).fit(X, y) @@ -114,12 +116,12 @@ def test_random_starts(): def test_custom_optimizer(): """ Test that GPC can use externally defined optimizers. """ - # Define a dummy optimizer that simply tests 1000 random hyperparameters + # Define a dummy optimizer that simply tests 50 random hyperparameters def optimizer(obj_func, initial_theta, bounds): rng = np.random.RandomState(0) theta_opt, func_min = \ initial_theta, obj_func(initial_theta, eval_gradient=False) - for _ in range(1000): + for _ in range(50): theta = np.atleast_1d(rng.uniform(np.maximum(-2, bounds[:, 0]), np.minimum(1, bounds[:, 1]))) f = obj_func(theta, eval_gradient=False) @@ -128,7 +130,8 @@ def optimizer(obj_func, initial_theta, bounds): return theta_opt, func_min for kernel in kernels: - if kernel == fixed_kernel: continue + if kernel == fixed_kernel: + continue gpc = GaussianProcessClassifier(kernel=kernel, optimizer=optimizer) gpc.fit(X, y_mc) # Checks that optimizer improved marginal likelihood From e6a9e24bca61cdfa390db26fb4e2143949f4315d Mon Sep 17 00:00:00 2001 From: giorgiop Date: Wed, 4 Nov 2015 10:20:21 +0100 Subject: [PATCH 2/8] test_gpr --- sklearn/gaussian_process/tests/test_gpr.py | 44 ++++++++++++---------- 1 file changed, 24 insertions(+), 20 deletions(-) diff --git a/sklearn/gaussian_process/tests/test_gpr.py b/sklearn/gaussian_process/tests/test_gpr.py index 218054dbbb52f..745ac2433116c 100644 --- a/sklearn/gaussian_process/tests/test_gpr.py +++ b/sklearn/gaussian_process/tests/test_gpr.py @@ -25,14 +25,14 @@ def f(x): fixed_kernel = RBF(length_scale=1.0, length_scale_bounds="fixed") kernels = [RBF(length_scale=1.0), fixed_kernel, RBF(length_scale=1.0, length_scale_bounds=(1e-3, 1e3)), - C(1.0, (1e-2, 1e2)) - * RBF(length_scale=1.0, length_scale_bounds=(1e-3, 1e3)), - C(1.0, (1e-2, 1e2)) - * RBF(length_scale=1.0, length_scale_bounds=(1e-3, 1e3)) - + C(1e-5, (1e-5, 1e2)), - C(0.1, (1e-2, 1e2)) - * RBF(length_scale=1.0, length_scale_bounds=(1e-3, 1e3)) - + C(1e-5, (1e-5, 1e2))] + C(1.0, (1e-2, 1e2)) * + RBF(length_scale=1.0, length_scale_bounds=(1e-3, 1e3)), + C(1.0, (1e-2, 1e2)) * + RBF(length_scale=1.0, length_scale_bounds=(1e-3, 1e3)) + + C(1e-5, (1e-5, 1e2)), + C(0.1, (1e-2, 1e2)) * + RBF(length_scale=1.0, length_scale_bounds=(1e-3, 1e3)) + + C(1e-5, (1e-5, 1e2))] def test_gpr_interpolation(): @@ -48,7 +48,8 @@ def test_gpr_interpolation(): def test_lml_improving(): """ Test that hyperparameter-tuning improves log-marginal likelihood. """ for kernel in kernels: - if kernel == fixed_kernel: continue + if kernel == fixed_kernel: + continue gpr = GaussianProcessRegressor(kernel=kernel).fit(X, y) assert_greater(gpr.log_marginal_likelihood(gpr.kernel_.theta), gpr.log_marginal_likelihood(kernel.theta)) @@ -65,21 +66,23 @@ def test_lml_precomputed(): def test_converged_to_local_maximum(): """ Test that we are in local maximum after hyperparameter-optimization.""" for kernel in kernels: - if kernel == fixed_kernel: continue + if kernel == fixed_kernel: + continue gpr = GaussianProcessRegressor(kernel=kernel).fit(X, y) lml, lml_gradient = \ gpr.log_marginal_likelihood(gpr.kernel_.theta, True) - assert_true(np.all((np.abs(lml_gradient) < 1e-4) - | (gpr.kernel_.theta == gpr.kernel_.bounds[:, 0]) - | (gpr.kernel_.theta == gpr.kernel_.bounds[:, 1]))) + assert_true(np.all((np.abs(lml_gradient) < 1e-4) | + (gpr.kernel_.theta == gpr.kernel_.bounds[:, 0]) | + (gpr.kernel_.theta == gpr.kernel_.bounds[:, 1]))) def test_solution_inside_bounds(): """ Test that hyperparameter-optimization remains in bounds""" for kernel in kernels: - if kernel == fixed_kernel: continue + if kernel == fixed_kernel: + continue gpr = GaussianProcessRegressor(kernel=kernel).fit(X, y) bounds = gpr.kernel_.bounds @@ -128,7 +131,7 @@ def test_sample_statistics(): y_mean, y_cov = gpr.predict(X2, return_cov=True) - samples = gpr.sample_y(X2, 1000000) + samples = gpr.sample_y(X2, 300000) # More digits accuracy would require many more samples assert_almost_equal(y_mean, np.mean(samples, 1), 2) @@ -172,7 +175,7 @@ def test_random_starts(): Test that an increasing number of random-starts of GP fitting only increases the log marginal likelihood of the chosen theta. """ - n_samples, n_features = 25, 3 + n_samples, n_features = 25, 2 np.random.seed(0) rng = np.random.RandomState(0) X = rng.randn(n_samples, n_features) * 2 - 1 @@ -184,7 +187,7 @@ def test_random_starts(): length_scale_bounds=[(1e-4, 1e+2)] * n_features) \ + WhiteKernel(noise_level=1e-5, noise_level_bounds=(1e-5, 1e1)) last_lml = -np.inf - for n_restarts_optimizer in range(9): + for n_restarts_optimizer in range(5): gp = GaussianProcessRegressor( kernel=kernel, n_restarts_optimizer=n_restarts_optimizer, random_state=0,).fit(X, y) @@ -267,12 +270,12 @@ def test_y_multioutput(): def test_custom_optimizer(): """ Test that GPR can use externally defined optimizers. """ - # Define a dummy optimizer that simply tests 1000 random hyperparameters + # Define a dummy optimizer that simply tests 50 random hyperparameters def optimizer(obj_func, initial_theta, bounds): rng = np.random.RandomState(0) theta_opt, func_min = \ initial_theta, obj_func(initial_theta, eval_gradient=False) - for _ in range(1000): + for _ in range(50): theta = np.atleast_1d(rng.uniform(np.maximum(-2, bounds[:, 0]), np.minimum(1, bounds[:, 1]))) f = obj_func(theta, eval_gradient=False) @@ -281,7 +284,8 @@ def optimizer(obj_func, initial_theta, bounds): return theta_opt, func_min for kernel in kernels: - if kernel == fixed_kernel: continue + if kernel == fixed_kernel: + continue gpr = GaussianProcessRegressor(kernel=kernel, optimizer=optimizer) gpr.fit(X, y) # Checks that optimizer improved marginal likelihood From 12c385521373e8e0864dffe4e0cb5950b22cbd69 Mon Sep 17 00:00:00 2001 From: giorgiop Date: Wed, 4 Nov 2015 11:05:24 +0100 Subject: [PATCH 3/8] test_kernels --- sklearn/gaussian_process/tests/test_kernels.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/sklearn/gaussian_process/tests/test_kernels.py b/sklearn/gaussian_process/tests/test_kernels.py index 93bee24419ec2..fc50ffbcae7b7 100644 --- a/sklearn/gaussian_process/tests/test_kernels.py +++ b/sklearn/gaussian_process/tests/test_kernels.py @@ -23,8 +23,8 @@ assert_array_almost_equal) -X = np.random.RandomState(0).normal(0, 1, (10, 2)) -Y = np.random.RandomState(0).normal(0, 1, (11, 2)) +X = np.random.RandomState(0).normal(0, 1, (5, 2)) +Y = np.random.RandomState(0).normal(0, 1, (6, 2)) kernel_white = RBF(length_scale=2.0) + WhiteKernel(noise_level=3.0) kernels = [RBF(length_scale=2.0), RBF(length_scale_bounds=(0.5, 2.0)), From 368943ca62423d1c0e3e04a0e42b5e1b53cb6f98 Mon Sep 17 00:00:00 2001 From: giorgiop Date: Wed, 4 Nov 2015 12:52:22 +0100 Subject: [PATCH 4/8] test_extmath --- sklearn/utils/tests/test_extmath.py | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/sklearn/utils/tests/test_extmath.py b/sklearn/utils/tests/test_extmath.py index 9654d6c76b9bc..388c0803fb203 100644 --- a/sklearn/utils/tests/test_extmath.py +++ b/sklearn/utils/tests/test_extmath.py @@ -226,7 +226,7 @@ def test_randomized_svd_infinite_rank(): def test_randomized_svd_transpose_consistency(): - # Check that transposing the design matrix has limit impact + # Check that transposing the design matrix has limited impact n_samples = 100 n_features = 500 rank = 4 @@ -262,7 +262,7 @@ def test_randomized_svd_power_iteration_normalizer(): # randomized_svd with power_iteration_normalized='none' diverges for # large number of power iterations on this dataset rng = np.random.RandomState(42) - X = make_low_rank_matrix(300, 1000, effective_rank=50, random_state=rng) + X = make_low_rank_matrix(100, 500, effective_rank=50, random_state=rng) X += 3 * rng.randint(0, 2, size=X.shape) n_components = 50 @@ -275,7 +275,6 @@ def test_randomized_svd_power_iteration_normalizer(): power_iteration_normalizer='none') A = X - U.dot(np.diag(s).dot(V)) error_20 = linalg.norm(A, ord='fro') - print(error_2 - error_20) assert_greater(np.abs(error_2 - error_20), 100) for normalizer in ['LU', 'QR', 'auto']: @@ -289,7 +288,6 @@ def test_randomized_svd_power_iteration_normalizer(): power_iteration_normalizer=normalizer) A = X - U.dot(np.diag(s).dot(V)) error = linalg.norm(A, ord='fro') - print(error_2 - error) assert_greater(15, np.abs(error_2 - error)) @@ -358,8 +356,8 @@ def test_cartesian(): def test_logistic_sigmoid(): # Check correctness and robustness of logistic sigmoid implementation - naive_logistic = lambda x: 1 / (1 + np.exp(-x)) - naive_log_logistic = lambda x: np.log(naive_logistic(x)) + def naive_log_logistic(x): + return np.log(1 / (1 + np.exp(-x))) x = np.linspace(-2, 2, 50) assert_array_almost_equal(log_logistic(x), naive_log_logistic(x)) From 34ced097189787e3d4791a1f11add08ecc218183 Mon Sep 17 00:00:00 2001 From: giorgiop Date: Wed, 4 Nov 2015 13:43:01 +0100 Subject: [PATCH 5/8] test_coordinate_descent --- .../tests/test_coordinate_descent.py | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/sklearn/linear_model/tests/test_coordinate_descent.py b/sklearn/linear_model/tests/test_coordinate_descent.py index f38217a947dae..ecca8009305d3 100644 --- a/sklearn/linear_model/tests/test_coordinate_descent.py +++ b/sklearn/linear_model/tests/test_coordinate_descent.py @@ -167,8 +167,8 @@ def test_lasso_cv(): # for this we check that they don't fall in the grid of # clf.alphas further than 1 assert_true(np.abs( - np.searchsorted(clf.alphas_[::-1], lars.alpha_) - - np.searchsorted(clf.alphas_[::-1], clf.alpha_)) <= 1) + np.searchsorted(clf.alphas_[::-1], lars.alpha_) - + np.searchsorted(clf.alphas_[::-1], clf.alpha_)) <= 1) # check that they also give a similar MSE mse_lars = interpolate.interp1d(lars.cv_alphas_, lars.cv_mse_path_.T) np.testing.assert_approx_equal(mse_lars(clf.alphas_[5]).mean(), @@ -438,29 +438,29 @@ def test_multioutput_enetcv_error(): def test_multitask_enet_and_lasso_cv(): - X, y, _, _ = build_dataset(n_features=100, n_targets=3) + X, y, _, _ = build_dataset(n_features=50, n_targets=3) clf = MultiTaskElasticNetCV().fit(X, y) assert_almost_equal(clf.alpha_, 0.00556, 3) clf = MultiTaskLassoCV().fit(X, y) assert_almost_equal(clf.alpha_, 0.00278, 3) X, y, _, _ = build_dataset(n_targets=3) - clf = MultiTaskElasticNetCV(n_alphas=50, eps=1e-3, max_iter=100, + clf = MultiTaskElasticNetCV(n_alphas=10, eps=1e-3, max_iter=100, l1_ratio=[0.3, 0.5], tol=1e-3) clf.fit(X, y) assert_equal(0.5, clf.l1_ratio_) assert_equal((3, X.shape[1]), clf.coef_.shape) assert_equal((3, ), clf.intercept_.shape) - assert_equal((2, 50, 3), clf.mse_path_.shape) - assert_equal((2, 50), clf.alphas_.shape) + assert_equal((2, 10, 3), clf.mse_path_.shape) + assert_equal((2, 10), clf.alphas_.shape) X, y, _, _ = build_dataset(n_targets=3) - clf = MultiTaskLassoCV(n_alphas=50, eps=1e-3, max_iter=100, tol=1e-3) + clf = MultiTaskLassoCV(n_alphas=10, eps=1e-3, max_iter=100, tol=1e-3) clf.fit(X, y) assert_equal((3, X.shape[1]), clf.coef_.shape) assert_equal((3, ), clf.intercept_.shape) - assert_equal((50, 3), clf.mse_path_.shape) - assert_equal(50, len(clf.alphas_)) + assert_equal((10, 3), clf.mse_path_.shape) + assert_equal(10, len(clf.alphas_)) def test_1d_multioutput_enet_and_multitask_enet_cv(): From 7c31d554759ff1bd34be241205c7ac9a4f78689b Mon Sep 17 00:00:00 2001 From: giorgiop Date: Wed, 4 Nov 2015 14:30:16 +0100 Subject: [PATCH 6/8] split long test in test_neighbors --- sklearn/neighbors/tests/test_neighbors.py | 50 +++++++++++++---------- 1 file changed, 29 insertions(+), 21 deletions(-) diff --git a/sklearn/neighbors/tests/test_neighbors.py b/sklearn/neighbors/tests/test_neighbors.py index 35eb1edf6fd0a..150070e77fe1d 100644 --- a/sklearn/neighbors/tests/test_neighbors.py +++ b/sklearn/neighbors/tests/test_neighbors.py @@ -1,6 +1,4 @@ from itertools import product -import pickle - import numpy as np from scipy.sparse import (bsr_matrix, coo_matrix, csc_matrix, csr_matrix, dok_matrix, lil_matrix) @@ -748,8 +746,8 @@ def test_neighbors_iris(): rgs = neighbors.KNeighborsRegressor(n_neighbors=5, algorithm=algorithm) rgs.fit(iris.data, iris.target) - assert_true(np.mean(rgs.predict(iris.data).round() == iris.target) - > 0.95) + assert_true(np.mean(rgs.predict(iris.data).round() == iris.target) > + 0.95) def test_neighbors_digits(): @@ -777,7 +775,8 @@ def test_kneighbors_graph(): X = np.array([[0, 1], [1.01, 1.], [2, 0]]) # n_neighbors = 1 - A = neighbors.kneighbors_graph(X, 1, mode='connectivity', include_self=True) + A = neighbors.kneighbors_graph(X, 1, mode='connectivity', + include_self=True) assert_array_equal(A.toarray(), np.eye(A.shape[0])) A = neighbors.kneighbors_graph(X, 1, mode='distance') @@ -788,7 +787,8 @@ def test_kneighbors_graph(): [0.00, 1.40716026, 0.]]) # n_neighbors = 2 - A = neighbors.kneighbors_graph(X, 2, mode='connectivity', include_self=True) + A = neighbors.kneighbors_graph(X, 2, mode='connectivity', + include_self=True) assert_array_equal( A.toarray(), [[1., 1., 0.], @@ -803,7 +803,8 @@ def test_kneighbors_graph(): [2.23606798, 1.40716026, 0.]]) # n_neighbors = 3 - A = neighbors.kneighbors_graph(X, 3, mode='connectivity', include_self=True) + A = neighbors.kneighbors_graph(X, 3, mode='connectivity', + include_self=True) assert_array_almost_equal( A.toarray(), [[1, 1, 1], [1, 1, 1], [1, 1, 1]]) @@ -962,11 +963,13 @@ def test_neighbors_metrics(n_samples=20, n_features=3, def test_callable_metric(): - metric = lambda x1, x2: np.sqrt(np.sum(x1 ** 2 + x2 ** 2)) + + def callable(x1, x2): + return np.sqrt(np.sum(x1 ** 2 + x2 ** 2)) X = np.random.RandomState(42).rand(20, 2) - nbrs1 = neighbors.NearestNeighbors(3, algorithm='auto', metric=metric) - nbrs2 = neighbors.NearestNeighbors(3, algorithm='brute', metric=metric) + nbrs1 = neighbors.NearestNeighbors(3, algorithm='auto', metric=callable) + nbrs2 = neighbors.NearestNeighbors(3, algorithm='brute', metric=callable) nbrs1.fit(X) nbrs2.fit(X) @@ -1157,7 +1160,18 @@ def test_include_self_neighbors_graph(): assert_array_equal(rng_not_self, [[0., 1.], [1., 0.]]) -def test_kneighbors_parallel(): +def test_kneighbors_gel(): + + def assert_same_knn_parallel(y, dist, ind, A, clf_parallel): + y_parallel = clf.predict(X_test) + dist_parallel, ind_parallel = clf.kneighbors(X_test) + A_parallel = \ + clf.kneighbors_graph(X_test, mode='distance').toarray() + assert_array_equal(y, y_parallel) + assert_array_almost_equal(dist, dist_parallel) + assert_array_equal(ind, ind_parallel) + assert_array_almost_equal(A, A_parallel) + X, y = datasets.make_classification(n_samples=10, n_features=2, n_redundant=0, random_state=0) X_train, X_test, y_train, y_test = train_test_split(X, y) @@ -1165,18 +1179,12 @@ def test_kneighbors_parallel(): clf = neighbors.KNeighborsClassifier(n_neighbors=3, algorithm=algorithm) clf.fit(X_train, y_train) - y_1 = clf.predict(X_test) - dist_1, ind_1 = clf.kneighbors(X_test) - A_1 = clf.kneighbors_graph(X_test, mode='distance').toarray() + y = clf.predict(X_test) + dist, ind = clf.kneighbors(X_test) + A = clf.kneighbors_graph(X_test, mode='distance').toarray() for n_jobs in [-1, 2, 5]: clf.set_params(n_jobs=n_jobs) - y = clf.predict(X_test) - dist, ind = clf.kneighbors(X_test) - A = clf.kneighbors_graph(X_test, mode='distance').toarray() - assert_array_equal(y_1, y) - assert_array_almost_equal(dist_1, dist) - assert_array_equal(ind_1, ind) - assert_array_almost_equal(A_1, A) + yield assert_same_knn_parallel, y, dist, ind, A, clf def test_dtype_convert(): From 9ed589e935fbec977fd416b1bee01eb642bd9657 Mon Sep 17 00:00:00 2001 From: giorgiop Date: Wed, 4 Nov 2015 14:44:55 +0100 Subject: [PATCH 7/8] test_split --- sklearn/model_selection/tests/test_split.py | 46 +++++++++++---------- 1 file changed, 25 insertions(+), 21 deletions(-) diff --git a/sklearn/model_selection/tests/test_split.py b/sklearn/model_selection/tests/test_split.py index 4689ead6007d0..16176445ab529 100644 --- a/sklearn/model_selection/tests/test_split.py +++ b/sklearn/model_selection/tests/test_split.py @@ -41,7 +41,7 @@ from sklearn.model_selection import train_test_split from sklearn.model_selection import GridSearchCV -from sklearn.svm import LinearSVC +from sklearn.linear_model import Ridge from sklearn.model_selection._split import _safe_split from sklearn.model_selection._split import _validate_shuffle_split @@ -419,31 +419,33 @@ def test_shuffle_stratifiedkfold(): def test_kfold_can_detect_dependent_samples_on_digits(): # see #2372 # The digits samples are dependent: they are apparently grouped by authors # although we don't have any information on the groups segment locations - # for this data. We can highlight this fact be computing k-fold cross- + # for this data. We can highlight this fact by computing k-fold cross- # validation with and without shuffling: we observe that the shuffling case # wrongly makes the IID assumption and is therefore too optimistic: it - # estimates a much higher accuracy (around 0.96) than than the non - # shuffling variant (around 0.86). + # estimates a much higher accuracy (around 0.93) than that the non + # shuffling variant (around 0.81). - X, y = digits.data[:800], digits.target[:800] + X, y = digits.data[:600], digits.target[:600] model = SVC(C=10, gamma=0.005) - cv = KFold(n_folds=5, shuffle=False) + n_folds = 3 + + cv = KFold(n_folds=n_folds, shuffle=False) mean_score = cross_val_score(model, X, y, cv=cv).mean() - assert_greater(0.88, mean_score) - assert_greater(mean_score, 0.85) + assert_greater(0.92, mean_score) + assert_greater(mean_score, 0.80) # Shuffling the data artificially breaks the dependency and hides the # overfitting of the model with regards to the writing style of the authors # by yielding a seriously overestimated score: - cv = KFold(5, shuffle=True, random_state=0) + cv = KFold(n_folds, shuffle=True, random_state=0) mean_score = cross_val_score(model, X, y, cv=cv).mean() - assert_greater(mean_score, 0.95) + assert_greater(mean_score, 0.92) - cv = KFold(5, shuffle=True, random_state=1) + cv = KFold(n_folds, shuffle=True, random_state=1) mean_score = cross_val_score(model, X, y, cv=cv).mean() - assert_greater(mean_score, 0.95) + assert_greater(mean_score, 0.92) # Similarly, StratifiedKFold should try to shuffle the data as little # as possible (while respecting the balanced class constraints) @@ -452,10 +454,10 @@ def test_kfold_can_detect_dependent_samples_on_digits(): # see #2372 # the estimated mean score is close to the score measured with # non-shuffled KFold - cv = StratifiedKFold(5) + cv = StratifiedKFold(n_folds) mean_score = cross_val_score(model, X, y, cv=cv).mean() - assert_greater(0.88, mean_score) - assert_greater(mean_score, 0.85) + assert_greater(0.93, mean_score) + assert_greater(mean_score, 0.80) def test_shuffle_split(): @@ -517,10 +519,12 @@ def test_stratified_shuffle_split_iter(): for train, test in sss: assert_array_equal(np.unique(y[train]), np.unique(y[test])) # Checks if folds keep classes proportions - p_train = (np.bincount(np.unique(y[train], return_inverse=True)[1]) - / float(len(y[train]))) - p_test = (np.bincount(np.unique(y[test], return_inverse=True)[1]) - / float(len(y[test]))) + p_train = (np.bincount(np.unique(y[train], + return_inverse=True)[1]) / + float(len(y[train]))) + p_test = (np.bincount(np.unique(y[test], + return_inverse=True)[1]) / + float(len(y[test]))) assert_array_almost_equal(p_train, p_test, 1) assert_equal(y[train].size + y[test].size, y.size) assert_array_equal(np.lib.arraysetops.intersect1d(train, test), []) @@ -946,10 +950,10 @@ def test_nested_cv(): labels = rng.randint(0, 5, 15) cvs = [LeaveOneLabelOut(), LeaveOneOut(), LabelKFold(), StratifiedKFold(), - StratifiedShuffleSplit(n_iter=10, random_state=0)] + StratifiedShuffleSplit(n_iter=3, random_state=0)] for inner_cv, outer_cv in combinations_with_replacement(cvs, 2): - gs = GridSearchCV(LinearSVC(random_state=0), param_grid={'C': [1, 10]}, + gs = GridSearchCV(Ridge(), param_grid={'alpha': [1, .1]}, cv=inner_cv) cross_val_score(gs, X=X, y=y, labels=labels, cv=outer_cv, fit_params={'labels': labels}) From 210b8f74238427ade014f5e10dae0a920bcdeb65 Mon Sep 17 00:00:00 2001 From: giorgiop Date: Thu, 5 Nov 2015 09:43:24 +0100 Subject: [PATCH 8/8] test_kernels.test_kernel_gradient --- .../gaussian_process/tests/test_kernels.py | 19 ++++++++----------- 1 file changed, 8 insertions(+), 11 deletions(-) diff --git a/sklearn/gaussian_process/tests/test_kernels.py b/sklearn/gaussian_process/tests/test_kernels.py index fc50ffbcae7b7..5adc3119ab184 100644 --- a/sklearn/gaussian_process/tests/test_kernels.py +++ b/sklearn/gaussian_process/tests/test_kernels.py @@ -8,7 +8,7 @@ import numpy as np -from scipy.optimize import approx_fprime +from sklearn.gaussian_process.kernels import _approx_fprime from sklearn.metrics.pairwise \ import PAIRWISE_KERNEL_FUNCTIONS, euclidean_distances, pairwise_kernels @@ -57,16 +57,13 @@ def test_kernel_gradient(): assert_equal(K_gradient.shape[1], X.shape[0]) assert_equal(K_gradient.shape[2], kernel.theta.shape[0]) - K_gradient_approx = np.empty_like(K_gradient) - for i in range(K.shape[0]): - for j in range(K.shape[1]): - def eval_kernel_ij_for_theta(theta): - kernel_clone = kernel.clone_with_theta(theta) - K = kernel_clone(X, eval_gradient=False) - return K[i, j] - K_gradient_approx[i, j] = \ - approx_fprime(kernel.theta, eval_kernel_ij_for_theta, - 1e-10) + def eval_kernel_for_theta(theta): + kernel_clone = kernel.clone_with_theta(theta) + K = kernel_clone(X, eval_gradient=False) + return K + + K_gradient_approx = \ + _approx_fprime(kernel.theta, eval_kernel_for_theta, 1e-10) assert_almost_equal(K_gradient, K_gradient_approx, 4)