Beispiel #1
0
def test_compare_with_sklearn(svd_solver, batch_number):
    X = iris.data
    X_da = da.from_array(X, chunks=(3, -1))
    batch_size = X.shape[0] // batch_number
    ipca = sd.IncrementalPCA(n_components=2, batch_size=batch_size)
    ipca.fit(X)
    ipca_da = IncrementalPCA(n_components=2,
                             batch_size=batch_size,
                             svd_solver=svd_solver)
    ipca_da.fit(X_da)
    np.testing.assert_allclose(
        flip_vector_signs(ipca.components_, 1),
        flip_vector_signs(ipca_da.components_, 1),
        atol=1e-13,
    )
    np.testing.assert_allclose(ipca.explained_variance_,
                               ipca_da.explained_variance_,
                               atol=1e-13)
    np.testing.assert_allclose(ipca.explained_variance_,
                               ipca_da.explained_variance_,
                               atol=1e-13)
    np.testing.assert_allclose(ipca.explained_variance_ratio_,
                               ipca_da.explained_variance_ratio_,
                               atol=1e-13)
    if svd_solver == "randomized":
        # noise variance in randomized solver is probabilistic.
        assert_almost_equal(ipca.noise_variance_,
                            ipca_da.noise_variance_,
                            decimal=1)
    else:
        np.testing.assert_allclose(ipca.noise_variance_,
                                   ipca_da.noise_variance_,
                                   atol=1e-13)
Beispiel #2
0
def test_basic():
    a = dd.PCA()
    b = sd.PCA()
    a.fit(dX)
    b.fit(X)
    assert_estimator_equal(a, b, exclude=["components_"])
    np.testing.assert_allclose(
        flip_vector_signs(a.components_, 1), flip_vector_signs(b.components_, 1)
    )
Beispiel #3
0
def test_algorithms():
    svd_a = sd.TruncatedSVD(30, algorithm="arpack")
    svd_r = dd.TruncatedSVD(30, algorithm="tsqr", random_state=42)

    Xa = svd_a.fit_transform(Xdense)[:, :6]
    Xr = svd_r.fit_transform(dXdense)[:, :6]
    assert_array_almost_equal(flip_vector_signs(Xa, axis=0),
                              flip_vector_signs(Xr, axis=0),
                              decimal=5)

    comp_a = np.abs(svd_a.components_)
    comp_r = np.abs(svd_r.components_)
    # All elements are equal, but some elements are more equal than others.
    assert_array_almost_equal(comp_a[:9], comp_r[:9])
    assert_array_almost_equal(comp_a[9:], comp_r[9:], decimal=2)
Beispiel #4
0
def test_basic(algorithm):
    a = dd.TruncatedSVD(random_state=0, algorithm=algorithm)
    b = sd.TruncatedSVD(random_state=0)
    b.fit(Xdense)
    a.fit(dXdense)

    np.testing.assert_allclose(
        flip_vector_signs(a.components_, axis=1),
        flip_vector_signs(b.components_, axis=1),
        atol=1e-3,
    )
    assert_estimator_equal(
        a, b, exclude=["components_", "explained_variance_"], atol=1e-3
    )
    assert a.explained_variance_.shape == b.explained_variance_.shape
    np.testing.assert_allclose(a.explained_variance_, b.explained_variance_, rtol=0.01)