def test_sgd_regressor_rk_as(loss): rng = np.random.RandomState(0) transform = RandomKernel(n_components=100, random_state=0, kernel='all_subsets') X_trans = transform.fit_transform(X) y, coef = generate_target(X_trans, rng, -0.1, 0.1) y_train = y[:n_train] y_test = y[n_train:] _test_regressor(transform, y_train, y_test, X_trans, loss=loss)
def test_anova_kernel(dist, degree, kernel): # compute exact kernel gram = anova(X, Y, degree) # approximate kernel mapping rk_transform = RandomKernel(n_components=1000, random_state=0, kernel=kernel, degree=degree, distribution=dist, p_sparse=0.5) X_trans = rk_transform.fit_transform(X) Y_trans = rk_transform.transform(Y) kernel_approx = np.dot(X_trans, Y_trans.T) error = gram - kernel_approx assert np.abs(np.mean(error)) < 0.0001 assert np.max(error) < 0.001 # nothing too far off assert np.mean(error) < 0.0005 # mean is fairly close # sparse input X_trans_sp = rk_transform.transform(X_sp) assert_allclose_dense_sparse(X_trans, X_trans_sp) # sparse output if dist == "sparse_rademacher": rk_transform.dense_output = False X_trans_sp = rk_transform.transform(X_sp) assert issparse(X_trans_sp) assert_allclose_dense_sparse(X_trans, X_trans_sp.toarray()) else: rk_transform.dense_output = False X_trans_sp = rk_transform.transform(X_sp) assert not issparse(X_trans_sp) assert_allclose_dense_sparse(X_trans, X_trans_sp)
def test_regressor_rk_as(normalize, loss): rng = np.random.RandomState(0) # approximate kernel mapping transformer = RandomKernel(n_components=100, random_state=0, kernel='all_subsets') X_trans = transformer.fit_transform(X) y, coef = generate_target(X_trans, rng, -0.1, 0.1) y_train = y[:n_train] y_test = y[n_train:] _test_regressor(transformer, X_train, y_train, X_test, y_test, X_trans, normalize=normalize, loss=loss)
def test_sgd_regressor_rk(loss): rng = np.random.RandomState(0) for degree in range(2, 5): transform = RandomKernel(n_components=100, random_state=0, degree=degree) X_trans = transform.fit_transform(X) y, coef = generate_target(X_trans, rng, -0.1, 0.1) y_train = y[:n_train] y_test = y[n_train:] _test_regressor(transform, y_train, y_test, X_trans, loss=loss)
def test_sparse_rademacher(p_sparse): # approximate kernel mapping for p_sparse in [0.9, 0.8, 0.7, 0.6, 0.5]: rk_transform = RandomKernel(n_components=1000, random_state=0, kernel='anova', distribution='sparse_rademacher', p_sparse=p_sparse) X_trans = rk_transform.fit_transform(X) nnz_actual = rk_transform.random_weights_.nnz nnz_expected = X.shape[1]*rk_transform.n_components*(1-p_sparse) assert_almost_equal(np.abs(1-nnz_actual/nnz_expected), 0, 0.1)
def test_classifier_rk(normalize, loss, degree): rng = np.random.RandomState(0) # approximate kernel mapping transformer = RandomKernel(n_components=100, random_state=0, degree=degree) X_trans = transformer.fit_transform(X) y, coef = generate_target(X_trans, rng, -0.1, 0.1) y_train = y[:n_train] y_test = y[n_train:] _test_classifier(transformer, X_train, np.sign(y_train), X_test, np.sign(y_test), X_trans, normalize=normalize, loss=loss)
def test_compact_random_feature_random_kernel_all_subsets(down): # approximate kernel mapping transform_up = RandomKernel(kernel='all_subsets', random_state=0, n_components=100) transform_down = down(n_components=50, random_state=0) X_trans_naive = transform_down.fit_transform(transform_up.fit_transform(X)) transform_up = RandomKernel(kernel='all_subsets', random_state=0, n_components=100) transform_down = down(n_components=50, random_state=0) transformer = CompactRandomFeature(transformer_up=transform_up, transformer_down=transform_down) X_trans = transformer.fit_transform(X) assert_allclose(X_trans_naive, X_trans)
def test_sgd_classifier_rk(loss): rng = np.random.RandomState(0) for degree in range(2, 5): transform = RandomKernel(n_components=100, random_state=0, degree=degree) X_trans = transform.fit_transform(X) y, coef = generate_target(X_trans, rng, -0.1, 0.1) y_train = y[:n_train] y_test = y[n_train:] _test_classifier(transform, np.sign(y_train), np.sign(y_test), X_trans, max_iter=100, eta0=.1, loss=loss)
def test_all_subsets_kernel(dist): # compute exact kernel p_sparse = 0.5 kernel = all_subsets(X, Y) # approximate kernel mapping rk_transform = RandomKernel(n_components=5000, random_state=0, kernel='all_subsets', distribution=dist, p_sparse=p_sparse) X_trans = rk_transform.fit_transform(X) Y_trans = rk_transform.transform(Y) kernel_approx = np.dot(X_trans, Y_trans.T) error = kernel - kernel_approx if dist == 'sparse_rademacher': nnz = rk_transform.random_weights_.nnz nnz_expect = np.prod(rk_transform.random_weights_.shape)*p_sparse nnz_var = np.sqrt(nnz_expect * (1-p_sparse)) assert np.abs(nnz-nnz_expect) < 3*nnz_var assert np.abs(np.mean(error)) < 0.01 assert np.max(error) < 0.1 # nothing too far off assert np.mean(error) < 0.05 # mean is fairly close X_trans_sp = rk_transform.transform(X_sp) assert_allclose_dense_sparse(X_trans, X_trans_sp)
if lkrf.remove_bases(): X_trans_removed = lkrf.transform(X) assert_almost_equal(X_trans_removed.shape[1], n_nz) indices = np.nonzero(lkrf.importance_weights_)[0] assert_almost_equal(X_trans_removed, X_trans[:, indices]) params = [ RBFSampler(n_components=128, random_state=0), RandomFourier(n_components=128, random_state=0), RandomFourier(n_components=128, random_state=0, use_offset=True), OrthogonalRandomFeature(n_components=128, random_state=0), OrthogonalRandomFeature(n_components=128, random_state=0, use_offset=True), RandomMaclaurin(random_state=0), RandomKernel(random_state=0) ] @pytest.mark.parametrize("transformer", params) def test_lkrf_chi2(transformer, rho=1): _test_learning_kernel_with_random_feature('chi2', transformer, rho) def test_lkrf_chi2_origin(): _test_learning_kernel_with_random_feature('chi2_origin') @pytest.mark.parametrize("transformer", params) def test_lkrf_kl(transformer): _test_learning_kernel_with_random_feature('kl', transformer, rho=0.01)