Beispiel #1
0
def test_knn_graph_sparse():
    k = 3
    n_pca = 20
    pca = TruncatedSVD(n_pca, random_state=42).fit(data)
    data_nu = pca.transform(data)
    pdx = squareform(pdist(data_nu, metric="euclidean"))
    knn_dist = np.partition(pdx, k, axis=1)[:, :k]
    epsilon = np.max(knn_dist, axis=1)
    K = np.empty_like(pdx)
    for i in range(len(pdx)):
        K[i, pdx[i, :] <= epsilon[i]] = 1
        K[i, pdx[i, :] > epsilon[i]] = 0

    K = K + K.T
    W = np.divide(K, 2)
    np.fill_diagonal(W, 0)
    G = pygsp.graphs.Graph(W)
    G2 = build_graph(
        sp.coo_matrix(data),
        n_pca=n_pca,
        decay=None,
        knn=k - 1,
        random_state=42,
        use_pygsp=True,
    )
    assert G.N == G2.N
    np.testing.assert_allclose(G2.W.toarray(), G.W.toarray())
    assert isinstance(G2, graphtools.graphs.kNNGraph)
Beispiel #2
0
def test_sparse_alpha_knn_graph():
    data = datasets.make_swiss_roll()[0]
    k = 5
    a = 0.45
    thresh = 0.01
    bandwidth_scale = 1.3
    pdx = squareform(pdist(data, metric="euclidean"))
    knn_dist = np.partition(pdx, k, axis=1)[:, :k]
    epsilon = np.max(knn_dist, axis=1) * bandwidth_scale
    pdx = (pdx.T / epsilon).T
    K = np.exp(-1 * pdx**a)
    K = K + K.T
    W = np.divide(K, 2)
    np.fill_diagonal(W, 0)
    G = pygsp.graphs.Graph(W)
    G2 = build_graph(
        data,
        n_pca=None,  # n_pca,
        decay=a,
        knn=k - 1,
        thresh=thresh,
        bandwidth_scale=bandwidth_scale,
        random_state=42,
        use_pygsp=True,
    )
    assert np.abs(G.W - G2.W).max() < thresh
    assert G.N == G2.N
    assert isinstance(G2, graphtools.graphs.kNNGraph)
def test_knn_graph_anisotropy():
    k = 3
    a = 13
    n_pca = 20
    anisotropy = 0.9
    thresh = 1e-4
    data_small = data[np.random.choice(len(data), len(data) // 2, replace=False)]
    pca = PCA(n_pca, svd_solver="randomized", random_state=42).fit(data_small)
    data_small_nu = pca.transform(data_small)
    pdx = squareform(pdist(data_small_nu, metric="euclidean"))
    knn_dist = np.partition(pdx, k, axis=1)[:, :k]
    epsilon = np.max(knn_dist, axis=1)
    weighted_pdx = (pdx.T / epsilon).T
    K = np.exp(-1 * weighted_pdx ** a)
    K[K < thresh] = 0
    K = K + K.T
    K = np.divide(K, 2)
    d = K.sum(1)
    W = K / (np.outer(d, d) ** anisotropy)
    np.fill_diagonal(W, 0)
    G = pygsp.graphs.Graph(W)
    G2 = build_graph(
        data_small,
        n_pca=n_pca,
        thresh=thresh,
        decay=a,
        knn=k - 1,
        random_state=42,
        use_pygsp=True,
        anisotropy=anisotropy,
    )
    assert isinstance(G2, graphtools.graphs.kNNGraph)
    assert G.N == G2.N
    np.testing.assert_allclose(G.dw, G2.dw, atol=1e-14, rtol=1e-14)
    np.testing.assert_allclose((G2.W - G.W).data, 0, atol=1e-14, rtol=1e-14)
Beispiel #4
0
def test_knn_graph_multiplication_symm():
    k = 3
    n_pca = 20
    pca = PCA(n_pca, svd_solver="randomized", random_state=42).fit(data)
    data_nu = pca.transform(data)
    pdx = squareform(pdist(data_nu, metric="euclidean"))
    knn_dist = np.partition(pdx, k, axis=1)[:, :k]
    epsilon = np.max(knn_dist, axis=1)
    K = np.empty_like(pdx)
    for i in range(len(pdx)):
        K[i, pdx[i, :] <= epsilon[i]] = 1
        K[i, pdx[i, :] > epsilon[i]] = 0

    W = K * K.T
    np.fill_diagonal(W, 0)
    G = pygsp.graphs.Graph(W)
    G2 = build_graph(
        data,
        n_pca=n_pca,
        decay=None,
        knn=k - 1,
        random_state=42,
        use_pygsp=True,
        kernel_symm="*",
    )
    assert G.N == G2.N
    np.testing.assert_equal(G.dw, G2.dw)
    assert (G.W - G2.W).nnz == 0
    assert (G2.W - G.W).sum() == 0
    assert isinstance(G2, graphtools.graphs.kNNGraph)
Beispiel #5
0
def test_knn_graph():
    k = 3
    n_pca = 20
    pca = PCA(n_pca, svd_solver='randomized', random_state=42).fit(data)
    data_nu = pca.transform(data)
    pdx = squareform(pdist(data_nu, metric='euclidean'))
    knn_dist = np.partition(pdx, k, axis=1)[:, :k]
    epsilon = np.max(knn_dist, axis=1)
    K = np.empty_like(pdx)
    for i in range(len(pdx)):
        K[i, pdx[i, :] <= epsilon[i]] = 1
        K[i, pdx[i, :] > epsilon[i]] = 0

    K = K + K.T
    W = np.divide(K, 2)
    np.fill_diagonal(W, 0)
    G = pygsp.graphs.Graph(W)
    G2 = build_graph(data, n_pca=n_pca,
                     decay=None, knn=k, random_state=42,
                     use_pygsp=True)
    assert(G.N == G2.N)
    assert(np.all(G.d == G2.d))
    assert((G.W != G2.W).nnz == 0)
    assert((G2.W != G.W).sum() == 0)
    assert(isinstance(G2, graphtools.graphs.kNNGraph))
Beispiel #6
0
def test_knnmax():
    data = datasets.make_swiss_roll()[0]
    k = 5
    k_max = 10
    a = 0.45
    thresh = 0

    with warnings.catch_warnings():
        warnings.filterwarnings("ignore", "K should be symmetric",
                                RuntimeWarning)
        G = build_graph(
            data,
            n_pca=None,  # n_pca,
            decay=a,
            knn=k - 1,
            knn_max=k_max - 1,
            thresh=0,
            random_state=42,
            kernel_symm=None,
        )
        assert np.all((G.K > 0).sum(axis=1) == k_max)

    pdx = squareform(pdist(data, metric="euclidean"))
    knn_dist = np.partition(pdx, k, axis=1)[:, :k]
    knn_max_dist = np.max(np.partition(pdx, k_max, axis=1)[:, :k_max], axis=1)
    epsilon = np.max(knn_dist, axis=1)
    pdx_scale = (pdx.T / epsilon).T
    K = np.where(pdx <= knn_max_dist[:, None], np.exp(-1 * pdx_scale**a), 0)
    K = K + K.T
    W = np.divide(K, 2)
    np.fill_diagonal(W, 0)
    G = pygsp.graphs.Graph(W)
    G2 = build_graph(
        data,
        n_pca=None,  # n_pca,
        decay=a,
        knn=k - 1,
        knn_max=k_max - 1,
        thresh=0,
        random_state=42,
        use_pygsp=True,
    )
    assert isinstance(G2, graphtools.graphs.kNNGraph)
    assert G.N == G2.N
    assert np.all(G.dw == G2.dw)
    assert (G.W - G2.W).nnz == 0
Beispiel #7
0
def test_truncated_exact_graph_no_pca():
    k = 3
    a = 13
    n_pca = None
    thresh = 1e-4
    data_small = data[np.random.choice(len(data),
                                       len(data) // 10,
                                       replace=False)]
    pdx = squareform(pdist(data_small, metric="euclidean"))
    knn_dist = np.partition(pdx, k, axis=1)[:, :k]
    epsilon = np.max(knn_dist, axis=1)
    weighted_pdx = (pdx.T / epsilon).T
    K = np.exp(-1 * weighted_pdx**a)
    K[K < thresh] = 0
    W = K + K.T
    W = np.divide(W, 2)
    np.fill_diagonal(W, 0)
    G = pygsp.graphs.Graph(W)
    G2 = build_graph(
        data_small,
        thresh=thresh,
        graphtype="exact",
        n_pca=n_pca,
        decay=a,
        knn=k - 1,
        random_state=42,
        use_pygsp=True,
    )
    assert G.N == G2.N
    np.testing.assert_equal(G.dw, G2.dw)
    assert (G.W != G2.W).nnz == 0
    assert (G2.W != G.W).sum() == 0
    assert isinstance(G2, graphtools.graphs.TraditionalGraph)
    G2 = build_graph(
        sp.csr_matrix(data_small),
        thresh=thresh,
        graphtype="exact",
        n_pca=n_pca,
        decay=a,
        knn=k - 1,
        random_state=42,
        use_pygsp=True,
    )
    assert G.N == G2.N
    np.testing.assert_equal(G.dw, G2.dw)
    assert (G.W != G2.W).nnz == 0
    assert (G2.W != G.W).sum() == 0
    assert isinstance(G2, graphtools.graphs.TraditionalGraph)
Beispiel #8
0
def test_knn_graph():
    k = 3
    n_pca = 20
    pca = PCA(n_pca, svd_solver="randomized", random_state=42).fit(data)
    data_nu = pca.transform(data)
    pdx = squareform(pdist(data_nu, metric="euclidean"))
    knn_dist = np.partition(pdx, k, axis=1)[:, :k]
    epsilon = np.max(knn_dist, axis=1)
    K = np.empty_like(pdx)
    for i in range(len(pdx)):
        K[i, pdx[i, :] <= epsilon[i]] = 1
        K[i, pdx[i, :] > epsilon[i]] = 0

    K = K + K.T
    W = np.divide(K, 2)
    np.fill_diagonal(W, 0)
    G = pygsp.graphs.Graph(W)
    G2 = build_graph(data,
                     n_pca=n_pca,
                     decay=None,
                     knn=k - 1,
                     random_state=42,
                     use_pygsp=True)
    assert G.N == G2.N
    np.testing.assert_equal(G.dw, G2.dw)
    assert (G.W - G2.W).nnz == 0
    assert (G2.W - G.W).sum() == 0
    assert isinstance(G2, graphtools.graphs.kNNGraph)

    K2 = G2.build_kernel_to_data(G2.data_nu, knn=k)
    K2 = (K2 + K2.T) / 2
    assert (G2.K - K2).nnz == 0
    assert (G2.build_kernel_to_data(
        G2.data_nu, knn=data.shape[0]).nnz == data.shape[0] * data.shape[0])
    with assert_warns_message(
            UserWarning,
            "Cannot set knn ({}) to be greater than "
            "n_samples ({}). Setting knn={}".format(data.shape[0] + 1,
                                                    data.shape[0],
                                                    data.shape[0]),
    ):
        G2.build_kernel_to_data(
            Y=G2.data_nu,
            knn=data.shape[0] + 1,
        )
Beispiel #9
0
def test_exact_graph_anisotropy():
    k = 3
    a = 13
    n_pca = 20
    anisotropy = 0.9
    data_small = data[np.random.choice(len(data),
                                       len(data) // 2,
                                       replace=False)]
    pca = PCA(n_pca, svd_solver="randomized", random_state=42).fit(data_small)
    data_small_nu = pca.transform(data_small)
    pdx = squareform(pdist(data_small_nu, metric="euclidean"))
    knn_dist = np.partition(pdx, k, axis=1)[:, :k]
    epsilon = np.max(knn_dist, axis=1)
    weighted_pdx = (pdx.T / epsilon).T
    K = np.exp(-1 * weighted_pdx**a)
    K = K + K.T
    K = np.divide(K, 2)
    d = K.sum(1)
    W = K / (np.outer(d, d)**anisotropy)
    np.fill_diagonal(W, 0)
    G = pygsp.graphs.Graph(W)
    G2 = build_graph(
        data_small,
        thresh=0,
        n_pca=n_pca,
        decay=a,
        knn=k - 1,
        random_state=42,
        use_pygsp=True,
        anisotropy=anisotropy,
    )
    assert isinstance(G2, graphtools.graphs.TraditionalGraph)
    assert G.N == G2.N
    np.testing.assert_equal(G.dw, G2.dw)
    assert (G2.W != G.W).sum() == 0
    assert (G.W != G2.W).nnz == 0
    with assert_raises_message(ValueError,
                               "Expected 0 <= anisotropy <= 1. Got -1"):
        build_graph(
            data_small,
            thresh=0,
            n_pca=n_pca,
            decay=a,
            knn=k - 1,
            random_state=42,
            use_pygsp=True,
            anisotropy=-1,
        )
    with assert_raises_message(ValueError,
                               "Expected 0 <= anisotropy <= 1. Got 2"):
        build_graph(
            data_small,
            thresh=0,
            n_pca=n_pca,
            decay=a,
            knn=k - 1,
            random_state=42,
            use_pygsp=True,
            anisotropy=2,
        )
    with assert_raises_message(ValueError,
                               "Expected 0 <= anisotropy <= 1. Got invalid"):
        build_graph(
            data_small,
            thresh=0,
            n_pca=n_pca,
            decay=a,
            knn=k - 1,
            random_state=42,
            use_pygsp=True,
            anisotropy="invalid",
        )
Beispiel #10
0
def test_truncated_exact_graph_sparse():
    k = 3
    a = 13
    n_pca = 20
    thresh = 1e-4
    data_small = data[np.random.choice(len(data),
                                       len(data) // 2,
                                       replace=False)]
    pca = TruncatedSVD(n_pca, random_state=42).fit(data_small)
    data_small_nu = pca.transform(data_small)
    pdx = squareform(pdist(data_small_nu, metric="euclidean"))
    knn_dist = np.partition(pdx, k, axis=1)[:, :k]
    epsilon = np.max(knn_dist, axis=1)
    weighted_pdx = (pdx.T / epsilon).T
    K = np.exp(-1 * weighted_pdx**a)
    K[K < thresh] = 0
    W = K + K.T
    W = np.divide(W, 2)
    np.fill_diagonal(W, 0)
    G = pygsp.graphs.Graph(W)
    G2 = build_graph(
        sp.coo_matrix(data_small),
        thresh=thresh,
        graphtype="exact",
        n_pca=n_pca,
        decay=a,
        knn=k - 1,
        random_state=42,
        use_pygsp=True,
    )
    assert G.N == G2.N
    np.testing.assert_allclose(G2.W.toarray(), G.W.toarray())
    assert isinstance(G2, graphtools.graphs.TraditionalGraph)
    G2 = build_graph(
        sp.bsr_matrix(pdx),
        n_pca=None,
        precomputed="distance",
        thresh=thresh,
        decay=a,
        knn=k - 1,
        random_state=42,
        use_pygsp=True,
    )
    assert G.N == G2.N
    np.testing.assert_equal(G.dw, G2.dw)
    assert (G.W != G2.W).nnz == 0
    assert (G2.W != G.W).sum() == 0
    assert isinstance(G2, graphtools.graphs.TraditionalGraph)
    G2 = build_graph(
        sp.lil_matrix(K),
        n_pca=None,
        precomputed="affinity",
        thresh=thresh,
        random_state=42,
        use_pygsp=True,
    )
    assert G.N == G2.N
    np.testing.assert_equal(G.dw, G2.dw)
    assert (G.W != G2.W).nnz == 0
    assert (G2.W != G.W).sum() == 0
    assert isinstance(G2, graphtools.graphs.TraditionalGraph)
    G2 = build_graph(
        sp.dok_matrix(W),
        n_pca=None,
        precomputed="adjacency",
        random_state=42,
        use_pygsp=True,
    )
    assert G.N == G2.N
    np.testing.assert_equal(G.dw, G2.dw)
    assert (G.W != G2.W).nnz == 0
    assert (G2.W != G.W).sum() == 0
    assert isinstance(G2, graphtools.graphs.TraditionalGraph)
Beispiel #11
0
def test_exact_graph():
    k = 3
    a = 13
    n_pca = 20
    bandwidth_scale = 1.3
    data_small = data[np.random.choice(len(data),
                                       len(data) // 2,
                                       replace=False)]
    pca = PCA(n_pca, svd_solver="randomized", random_state=42).fit(data_small)
    data_small_nu = pca.transform(data_small)
    pdx = squareform(pdist(data_small_nu, metric="euclidean"))
    knn_dist = np.partition(pdx, k, axis=1)[:, :k]
    epsilon = np.max(knn_dist, axis=1) * bandwidth_scale
    weighted_pdx = (pdx.T / epsilon).T
    K = np.exp(-1 * weighted_pdx**a)
    W = K + K.T
    W = np.divide(W, 2)
    np.fill_diagonal(W, 0)
    G = pygsp.graphs.Graph(W)
    G2 = build_graph(
        data_small,
        thresh=0,
        n_pca=n_pca,
        decay=a,
        knn=k - 1,
        random_state=42,
        bandwidth_scale=bandwidth_scale,
        use_pygsp=True,
    )
    assert G.N == G2.N
    np.testing.assert_equal(G.dw, G2.dw)
    assert (G.W != G2.W).nnz == 0
    assert (G2.W != G.W).sum() == 0
    assert isinstance(G2, graphtools.graphs.TraditionalGraph)
    G2 = build_graph(
        pdx,
        n_pca=None,
        precomputed="distance",
        bandwidth_scale=bandwidth_scale,
        decay=a,
        knn=k - 1,
        random_state=42,
        use_pygsp=True,
    )
    assert G.N == G2.N
    np.testing.assert_equal(G.dw, G2.dw)
    assert (G.W != G2.W).nnz == 0
    assert (G2.W != G.W).sum() == 0
    assert isinstance(G2, graphtools.graphs.TraditionalGraph)
    G2 = build_graph(
        sp.coo_matrix(K),
        n_pca=None,
        precomputed="affinity",
        random_state=42,
        use_pygsp=True,
    )
    assert G.N == G2.N
    np.testing.assert_equal(G.dw, G2.dw)
    assert (G.W != G2.W).nnz == 0
    assert (G2.W != G.W).sum() == 0
    assert isinstance(G2, graphtools.graphs.TraditionalGraph)
    G2 = build_graph(K,
                     n_pca=None,
                     precomputed="affinity",
                     random_state=42,
                     use_pygsp=True)
    assert G.N == G2.N
    np.testing.assert_equal(G.dw, G2.dw)
    assert (G.W != G2.W).nnz == 0
    assert (G2.W != G.W).sum() == 0
    assert isinstance(G2, graphtools.graphs.TraditionalGraph)
    G2 = build_graph(W,
                     n_pca=None,
                     precomputed="adjacency",
                     random_state=42,
                     use_pygsp=True)
    assert G.N == G2.N
    np.testing.assert_equal(G.dw, G2.dw)
    assert (G.W != G2.W).nnz == 0
    assert (G2.W != G.W).sum() == 0
    assert isinstance(G2, graphtools.graphs.TraditionalGraph)
Beispiel #12
0
def test_exact_graph():
    k = 3
    a = 13
    n_pca = 20
    data_small = data[np.random.choice(len(data),
                                       len(data) // 2,
                                       replace=False)]
    pca = PCA(n_pca, svd_solver='randomized', random_state=42).fit(data_small)
    data_small_nu = pca.transform(data_small)
    pdx = squareform(pdist(data_small_nu, metric='euclidean'))
    knn_dist = np.partition(pdx, k, axis=1)[:, :k]
    epsilon = np.max(knn_dist, axis=1)
    weighted_pdx = (pdx.T / epsilon).T
    K = np.exp(-1 * weighted_pdx**a)
    W = K + K.T
    W = np.divide(W, 2)
    np.fill_diagonal(W, 0)
    G = pygsp.graphs.Graph(W)
    G2 = build_graph(data_small,
                     thresh=0,
                     n_pca=n_pca,
                     decay=a,
                     knn=k,
                     random_state=42,
                     use_pygsp=True)
    assert (G.N == G2.N)
    assert (np.all(G.d == G2.d))
    assert ((G.W != G2.W).nnz == 0)
    assert ((G2.W != G.W).sum() == 0)
    assert (isinstance(G2, graphtools.graphs.TraditionalGraph))
    G2 = build_graph(pdx,
                     n_pca=None,
                     precomputed='distance',
                     decay=a,
                     knn=k,
                     random_state=42,
                     use_pygsp=True)
    assert (G.N == G2.N)
    assert (np.all(G.d == G2.d))
    assert ((G.W != G2.W).nnz == 0)
    assert ((G2.W != G.W).sum() == 0)
    assert (isinstance(G2, graphtools.graphs.TraditionalGraph))
    G2 = build_graph(sp.coo_matrix(K),
                     n_pca=None,
                     precomputed='affinity',
                     random_state=42,
                     use_pygsp=True)
    assert (G.N == G2.N)
    assert (np.all(G.d == G2.d))
    assert ((G.W != G2.W).nnz == 0)
    assert ((G2.W != G.W).sum() == 0)
    assert (isinstance(G2, graphtools.graphs.TraditionalGraph))
    G2 = build_graph(K,
                     n_pca=None,
                     precomputed='affinity',
                     random_state=42,
                     use_pygsp=True)
    assert (G.N == G2.N)
    assert (np.all(G.d == G2.d))
    assert ((G.W != G2.W).nnz == 0)
    assert ((G2.W != G.W).sum() == 0)
    assert (isinstance(G2, graphtools.graphs.TraditionalGraph))
    G2 = build_graph(W,
                     n_pca=None,
                     precomputed='adjacency',
                     random_state=42,
                     use_pygsp=True)
    assert (G.N == G2.N)
    assert (np.all(G.d == G2.d))
    assert ((G.W != G2.W).nnz == 0)
    assert ((G2.W != G.W).sum() == 0)
    assert (isinstance(G2, graphtools.graphs.TraditionalGraph))