profile graph-tool, igraph, networkx and pagerank with spmv (#19)

examples/profiling/.gitignore

+gt_bench
+igraph_bench
+nx_bench
+sp_bench
+dgl_bench
+pgp.xml

examples/profiling/README.md

+# Profiling the performance of graph-tool, igraph and Networkx
+
+## Settings
+We profiled graph-tool 2.26, igraph 0.7.1 and Networkx 2.1 (Python 3.6) on an Intel(R) Xeon(R) CPU E5-2620 v3 @ 2.40GHz with 6 cores.
+
+Benchmark scripts and sources are obtained from:
+https://graph-tool.skewed.de/performance
+
+The graph used in profiling is the strongly connected component of the PGP web of trust network circa November 2009. It is a directed graph, with 39,796 vertices and 301,498 edges.
+
+We did not use the betweenness benchmark due to the time it takes (10+ hours for NetworkX).
+
+For the PageRank benchmark of DGL (PageRank with SpMV), we assumed tensorized storage of adjacency matrix and degree vector.
+DGL was profiled with both CPU-only and GPU-enabled tensorflow (version 1.8.0).
+DGL (CPU) was profiled on the same CPU as graph-tool, igraph and NetworkX, and DGL (GPU) was profiled on a GeForce GTX TITAN X.
+
+## Profiling
+```
+bash pgp.sh
+bash profile.sh
+```
+
+## Results
+Average time per call:
+
+| Algorithm                   | graph-tool | igraph  | NetworkX | DGL (CPU) | DGL (GPU) |
+| --------------------------- | ---------- | ------- | -------- | --------- | --------- |
+| Single-source shortest path | 0.004 s    | 0.017 s | 0.484 s  | N/A       | N/A       |
+| PageRank                    | 0.009 s    | 0.239 s | 4.207 s  | 0.040 s   | 0.081 s   |
+| K-core                      | 0.010 s    | 0.029 s | 1.178 s  | N/A       | N/A       |
+| Minimum spanning tree       | 0.022 s    | 0.030 s | 1.961 s  | N/A       | N/A       |
+
+Profiling pagerank_scipy:
+
+| Operation                 | Time    |
+| ------------------------- | ------- |
+| nx.to_scipy_sparse_matrix | 1.34 s  |
+| np.ndarray to dict        | 0.01 s  |
+| Power iteration           | 0.001 s |
+| PageRank                  | 1.35 s  |

examples/profiling/gt_bench.py

+#!/bin/env python
+
+from graph_tool.all import *
+import cProfile
+
+g = load_graph("pgp.xml")
+
+print("Profiling shortest path")
+print("=======================")
+print()
+
+cProfile.run("for i in range(1000): shortest_distance(g, g.vertex(0))", sort="cumulative")
+
+print("Profiling PageRank")
+print("==================")
+print()
+
+cProfile.run("for i in range(100): pagerank(g, damping=0.85, epsilon=1e-3)", sort="cumulative")
+
+print("Profiling k-core")
+print("================")
+print()
+
+cProfile.run("for i in range(1000): kcore_decomposition(g)", sort="cumulative")
+# cProfile.run("for i in range(1000): kcore_decomposition(g, deg='total')", sort="cumulative")
+
+print("Profiling minimum spanning tree")
+print("===============================")
+print()
+
+cProfile.run("for i in range(1000): min_spanning_tree(g)", sort="cumulative")
+
+'''
+print("Profiling betweenness")
+print("=====================")
+print()
+
+cProfile.run("for i in range(3): betweenness(g)", sort="cumulative")
+'''

examples/profiling/gt_bench.sh

+echo "   ncalls  tottime  percall  cumtime  percall filename:lineno(function)"
+cat gt_bench | grep "__init__.py:1501(shortest_distance)"
+cat gt_bench | grep "__init__.py:62(pagerank)"
+cat gt_bench | grep "__init__.py:1427(kcore_decomposition)"
+cat gt_bench | grep "__init__.py:627(min_spanning_tree)"

examples/profiling/igraph_bench.py

+#!/bin/env python
+
+from igraph import *
+import cProfile
+
+g = Graph.Read_GraphML("pgp.xml")
+
+print("Profiling shortest path")
+print("=======================")
+print()
+
+cProfile.run("for i in range(1000): g.shortest_paths([g.vs[0]])", sort="cumulative")
+
+print("Profiling PageRank")
+print("==================")
+print()
+
+cProfile.run("for i in range(100): g.pagerank(damping=0.85)", sort="cumulative")
+
+print("Profiling k-core")
+print("================")
+print()
+
+cProfile.run("for i in range(1000): g.coreness(mode='all')", sort="cumulative")
+
+
+print("Profiling minimum spanning tree")
+print("===============================")
+print()
+
+cProfile.run("for i in range(1000): g.spanning_tree()", sort="cumulative")
+
+'''
+print("Profiling betweenness")
+print("=====================")
+print()
+
+cProfile.run("for i in range(3): g.betweenness(); g.edge_betweenness()", sort="cumulative")
+'''

examples/profiling/igraph_bench.sh

+echo "   ncalls  tottime  percall  cumtime  percall filename:lineno(function)"
+cat igraph_bench | grep "{method 'shortest_paths' of 'igraph.Graph' objects}"
+cat igraph_bench | grep "{method 'personalized_pagerank' of 'igraph.Graph' objects}"
+cat igraph_bench | grep "{method 'coreness' of 'igraph.Graph' objects}"
+cat igraph_bench | grep "{method 'subgraph_edges' of 'igraph.Graph' objects}"

examples/profiling/nx_bench.py

+#!/bin/env python
+from __future__ import print_function
+
+from networkx import *
+import cProfile
+
+g = read_graphml("pgp.xml")
+
+print("Profiling shortest path")
+print("=======================")
+print()
+
+cProfile.run("for i in range(100): shortest_path_length(g, 'n0')", sort="cumulative")
+
+
+print("Profiling PageRank")
+print("==================")
+print()
+
+cProfile.run("for i in range(10): pagerank(g, alpha=0.85, tol=1e-3, max_iter=10000000)", sort="cumulative")
+
+print("Profiling k-core")
+print("================")
+print()
+
+cProfile.run("for i in range(10): core.core_number(g)", sort="cumulative")
+
+
+print("Profiling minimum spanning tree")
+print("===============================")
+print()
+
+u = g.to_undirected()
+
+cProfile.run("for i in range(10): minimum_spanning_tree(u)", sort="cumulative")
+
+'''
+print("Profiling betweenness")
+print("====================")
+print()
+
+cProfile.run("for i in range(1): betweenness_centrality(g); edge_betweenness_centrality(g)", sort="cumulative")
+'''

examples/profiling/nx_bench.sh

+echo "   ncalls  tottime  percall  cumtime  percall filename:lineno(function)"
+cat nx_bench | grep "generic.py:149(shortest_path_length)"
+cat nx_bench | grep "pagerank_alg.py:16(pagerank)"
+cat nx_bench | grep "core.py:42(core_number)"
+cat nx_bench | grep "mst.py:493(minimum_spanning_tree)"

examples/profiling/pagerank_alg.py

+"""PageRank analysis of graph structure. """
+#    Copyright (C) 2004-2018 by
+#    Aric Hagberg <hagberg@lanl.gov>
+#    Dan Schult <dschult@colgate.edu>
+#    Pieter Swart <swart@lanl.gov>
+#    All rights reserved.
+#    BSD license.
+#    NetworkX:http://networkx.github.io/
+import time
+import networkx as nx
+from networkx.utils import not_implemented_for
+__author__ = """\n""".join(["Aric Hagberg <aric.hagberg@gmail.com>",
+                            "Brandon Liu <brandon.k.liu@gmail.com"])
+__all__ = ['pagerank', 'pagerank_numpy', 'pagerank_scipy', 'google_matrix']
+
+
+@not_implemented_for('multigraph')
+def pagerank(G, alpha=0.85, personalization=None,
+             max_iter=100, tol=1.0e-6, nstart=None, weight='weight',
+             dangling=None):
+    """Return the PageRank of the nodes in the graph.
+
+    PageRank computes a ranking of the nodes in the graph G based on
+    the structure of the incoming links. It was originally designed as
+    an algorithm to rank web pages.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph.  Undirected graphs will be converted to a directed
+      graph with two directed edges for each undirected edge.
+
+    alpha : float, optional
+      Damping parameter for PageRank, default=0.85.
+
+    personalization: dict, optional
+      The "personalization vector" consisting of a dictionary with a
+      key some subset of graph nodes and personalization value each of those.
+      At least one personalization value must be non-zero.
+      If not specfiied, a nodes personalization value will be zero.
+      By default, a uniform distribution is used.
+
+    max_iter : integer, optional
+      Maximum number of iterations in power method eigenvalue solver.
+
+    tol : float, optional
+      Error tolerance used to check convergence in power method solver.
+
+    nstart : dictionary, optional
+      Starting value of PageRank iteration for each node.
+
+    weight : key, optional
+      Edge data key to use as weight.  If None weights are set to 1.
+
+    dangling: dict, optional
+      The outedges to be assigned to any "dangling" nodes, i.e., nodes without
+      any outedges. The dict key is the node the outedge points to and the dict
+      value is the weight of that outedge. By default, dangling nodes are given
+      outedges according to the personalization vector (uniform if not
+      specified). This must be selected to result in an irreducible transition
+      matrix (see notes under google_matrix). It may be common to have the
+      dangling dict to be the same as the personalization dict.
+
+    Returns
+    -------
+    pagerank : dictionary
+       Dictionary of nodes with PageRank as value
+
+    Examples
+    --------
+    >>> G = nx.DiGraph(nx.path_graph(4))
+    >>> pr = nx.pagerank(G, alpha=0.9)
+
+    Notes
+    -----
+    The eigenvector calculation is done by the power iteration method
+    and has no guarantee of convergence.  The iteration will stop after
+    an error tolerance of ``len(G) * tol`` has been reached. If the
+    number of iterations exceed `max_iter`, a
+    :exc:`networkx.exception.PowerIterationFailedConvergence` exception
+    is raised.
+
+    The PageRank algorithm was designed for directed graphs but this
+    algorithm does not check if the input graph is directed and will
+    execute on undirected graphs by converting each edge in the
+    directed graph to two edges.
+
+    See Also
+    --------
+    pagerank_numpy, pagerank_scipy, google_matrix
+
+    Raises
+    ------
+    PowerIterationFailedConvergence
+        If the algorithm fails to converge to the specified tolerance
+        within the specified number of iterations of the power iteration
+        method.
+
+    References
+    ----------
+    .. [1] A. Langville and C. Meyer,
+       "A survey of eigenvector methods of web information retrieval."
+       http://citeseer.ist.psu.edu/713792.html
+    .. [2] Page, Lawrence; Brin, Sergey; Motwani, Rajeev and Winograd, Terry,
+       The PageRank citation ranking: Bringing order to the Web. 1999
+       http://dbpubs.stanford.edu:8090/pub/showDoc.Fulltext?lang=en&doc=1999-66&format=pdf
+
+    """
+    if len(G) == 0:
+        return {}
+
+    if not G.is_directed():
+        D = G.to_directed()
+    else:
+        D = G
+
+    # Create a copy in (right) stochastic form
+    W = nx.stochastic_graph(D, weight=weight)
+    N = W.number_of_nodes()
+
+    # Choose fixed starting vector if not given
+    if nstart is None:
+        x = dict.fromkeys(W, 1.0 / N)
+    else:
+        # Normalized nstart vector
+        s = float(sum(nstart.values()))
+        x = dict((k, v / s) for k, v in nstart.items())
+
+    if personalization is None:
+        # Assign uniform personalization vector if not given
+        p = dict.fromkeys(W, 1.0 / N)
+    else:
+        s = float(sum(personalization.values()))
+        p = dict((k, v / s) for k, v in personalization.items())
+
+    if dangling is None:
+        # Use personalization vector if dangling vector not specified
+        dangling_weights = p
+    else:
+        s = float(sum(dangling.values()))
+        dangling_weights = dict((k, v / s) for k, v in dangling.items())
+    dangling_nodes = [n for n in W if W.out_degree(n, weight=weight) == 0.0]
+
+    # power iteration: make up to max_iter iterations
+    for _ in range(max_iter):
+        xlast = x
+        x = dict.fromkeys(xlast.keys(), 0)
+        danglesum = alpha * sum(xlast[n] for n in dangling_nodes)
+        for n in x:
+            # this matrix multiply looks odd because it is
+            # doing a left multiply x^T=xlast^T*W
+            for nbr in W[n]:
+                x[nbr] += alpha * xlast[n] * W[n][nbr][weight]
+            x[n] += danglesum * dangling_weights.get(n, 0) + (1.0 - alpha) * p.get(n, 0)
+        # check convergence, l1 norm
+        err = sum([abs(x[n] - xlast[n]) for n in x])
+        if err < N * tol:
+            return x
+    raise nx.PowerIterationFailedConvergence(max_iter)
+
+
+def google_matrix(G, alpha=0.85, personalization=None,
+                  nodelist=None, weight='weight', dangling=None):
+    """Return the Google matrix of the graph.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph.  Undirected graphs will be converted to a directed
+      graph with two directed edges for each undirected edge.
+
+    alpha : float
+      The damping factor.
+
+    personalization: dict, optional
+      The "personalization vector" consisting of a dictionary with a
+      key some subset of graph nodes and personalization value each of those.
+      At least one personalization value must be non-zero.
+      If not specfiied, a nodes personalization value will be zero.
+      By default, a uniform distribution is used.
+
+    nodelist : list, optional
+      The rows and columns are ordered according to the nodes in nodelist.
+      If nodelist is None, then the ordering is produced by G.nodes().
+
+    weight : key, optional
+      Edge data key to use as weight.  If None weights are set to 1.
+
+    dangling: dict, optional
+      The outedges to be assigned to any "dangling" nodes, i.e., nodes without
+      any outedges. The dict key is the node the outedge points to and the dict
+      value is the weight of that outedge. By default, dangling nodes are given
+      outedges according to the personalization vector (uniform if not
+      specified) This must be selected to result in an irreducible transition
+      matrix (see notes below). It may be common to have the dangling dict to
+      be the same as the personalization dict.
+
+    Returns
+    -------
+    A : NumPy matrix
+       Google matrix of the graph
+
+    Notes
+    -----
+    The matrix returned represents the transition matrix that describes the
+    Markov chain used in PageRank. For PageRank to converge to a unique
+    solution (i.e., a unique stationary distribution in a Markov chain), the
+    transition matrix must be irreducible. In other words, it must be that
+    there exists a path between every pair of nodes in the graph, or else there
+    is the potential of "rank sinks."
+
+    This implementation works with Multi(Di)Graphs. For multigraphs the
+    weight between two nodes is set to be the sum of all edge weights
+    between those nodes.
+
+    See Also
+    --------
+    pagerank, pagerank_numpy, pagerank_scipy
+    """
+    import numpy as np
+
+    if nodelist is None:
+        nodelist = list(G)
+
+    M = nx.to_numpy_matrix(G, nodelist=nodelist, weight=weight)
+    N = len(G)
+    if N == 0:
+        return M
+
+    # Personalization vector
+    if personalization is None:
+        p = np.repeat(1.0 / N, N)
+    else:
+        p = np.array([personalization.get(n, 0) for n in nodelist], dtype=float)
+        p /= p.sum()
+
+    # Dangling nodes
+    if dangling is None:
+        dangling_weights = p
+    else:
+        # Convert the dangling dictionary into an array in nodelist order
+        dangling_weights = np.array([dangling.get(n, 0) for n in nodelist],
+                                    dtype=float)
+        dangling_weights /= dangling_weights.sum()
+    dangling_nodes = np.where(M.sum(axis=1) == 0)[0]
+
+    # Assign dangling_weights to any dangling nodes (nodes with no out links)
+    for node in dangling_nodes:
+        M[node] = dangling_weights
+
+    M /= M.sum(axis=1)  # Normalize rows to sum to 1
+
+    return alpha * M + (1 - alpha) * p
+
+
+def pagerank_numpy(G, alpha=0.85, personalization=None, weight='weight',
+                   dangling=None):
+    """Return the PageRank of the nodes in the graph.
+
+    PageRank computes a ranking of the nodes in the graph G based on
+    the structure of the incoming links. It was originally designed as
+    an algorithm to rank web pages.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph.  Undirected graphs will be converted to a directed
+      graph with two directed edges for each undirected edge.
+
+    alpha : float, optional
+      Damping parameter for PageRank, default=0.85.
+
+    personalization: dict, optional
+      The "personalization vector" consisting of a dictionary with a
+      key some subset of graph nodes and personalization value each of those.
+      At least one personalization value must be non-zero.
+      If not specfiied, a nodes personalization value will be zero.
+      By default, a uniform distribution is used.
+
+    weight : key, optional
+      Edge data key to use as weight.  If None weights are set to 1.
+
+    dangling: dict, optional
+      The outedges to be assigned to any "dangling" nodes, i.e., nodes without
+      any outedges. The dict key is the node the outedge points to and the dict
+      value is the weight of that outedge. By default, dangling nodes are given
+      outedges according to the personalization vector (uniform if not
+      specified) This must be selected to result in an irreducible transition
+      matrix (see notes under google_matrix). It may be common to have the
+      dangling dict to be the same as the personalization dict.
+
+    Returns
+    -------
+    pagerank : dictionary
+       Dictionary of nodes with PageRank as value.
+
+    Examples
+    --------
+    >>> G = nx.DiGraph(nx.path_graph(4))
+    >>> pr = nx.pagerank_numpy(G, alpha=0.9)
+
+    Notes
+    -----
+    The eigenvector calculation uses NumPy's interface to the LAPACK
+    eigenvalue solvers.  This will be the fastest and most accurate
+    for small graphs.
+
+    This implementation works with Multi(Di)Graphs. For multigraphs the
+    weight between two nodes is set to be the sum of all edge weights
+    between those nodes.
+
+    See Also
+    --------
+    pagerank, pagerank_scipy, google_matrix
+
+    References
+    ----------
+    .. [1] A. Langville and C. Meyer,
+       "A survey of eigenvector methods of web information retrieval."
+       http://citeseer.ist.psu.edu/713792.html
+    .. [2] Page, Lawrence; Brin, Sergey; Motwani, Rajeev and Winograd, Terry,
+       The PageRank citation ranking: Bringing order to the Web. 1999
+       http://dbpubs.stanford.edu:8090/pub/showDoc.Fulltext?lang=en&doc=1999-66&format=pdf
+    """
+    import numpy as np
+    if len(G) == 0:
+        return {}
+    M = google_matrix(G, alpha, personalization=personalization,
+                      weight=weight, dangling=dangling)
+    # use numpy LAPACK solver
+    eigenvalues, eigenvectors = np.linalg.eig(M.T)
+    ind = np.argmax(eigenvalues)
+    # eigenvector of largest eigenvalue is at ind, normalized
+    largest = np.array(eigenvectors[:, ind]).flatten().real
+    norm = float(largest.sum())
+    return dict(zip(G, map(float, largest / norm)))
+
+
+def pagerank_scipy(G, alpha=0.85, personalization=None,
+                   max_iter=100, tol=1.0e-6, weight='weight',
+                   dangling=None):
+    """Return the PageRank of the nodes in the graph.
+
+    PageRank computes a ranking of the nodes in the graph G based on
+    the structure of the incoming links. It was originally designed as
+    an algorithm to rank web pages.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph.  Undirected graphs will be converted to a directed
+      graph with two directed edges for each undirected edge.
+
+    alpha : float, optional
+      Damping parameter for PageRank, default=0.85.
+
+    personalization: dict, optional
+      The "personalization vector" consisting of a dictionary with a
+      key some subset of graph nodes and personalization value each of those.
+      At least one personalization value must be non-zero.
+      If not specfiied, a nodes personalization value will be zero.
+      By default, a uniform distribution is used.
+
+    max_iter : integer, optional
+      Maximum number of iterations in power method eigenvalue solver.
+
+    tol : float, optional
+      Error tolerance used to check convergence in power method solver.
+
+    weight : key, optional
+      Edge data key to use as weight.  If None weights are set to 1.
+
+    dangling: dict, optional
+      The outedges to be assigned to any "dangling" nodes, i.e., nodes without
+      any outedges. The dict key is the node the outedge points to and the dict
+      value is the weight of that outedge. By default, dangling nodes are given
+      outedges according to the personalization vector (uniform if not
+      specified) This must be selected to result in an irreducible transition
+      matrix (see notes under google_matrix). It may be common to have the
+      dangling dict to be the same as the personalization dict.
+
+    Returns
+    -------
+    pagerank : dictionary
+       Dictionary of nodes with PageRank as value
+
+    Examples
+    --------
+    >>> G = nx.DiGraph(nx.path_graph(4))
+    >>> pr = nx.pagerank_scipy(G, alpha=0.9)
+
+    Notes
+    -----
+    The eigenvector calculation uses power iteration with a SciPy
+    sparse matrix representation.
+
+    This implementation works with Multi(Di)Graphs. For multigraphs the
+    weight between two nodes is set to be the sum of all edge weights
+    between those nodes.
+
+    See Also
+    --------
+    pagerank, pagerank_numpy, google_matrix
+
+    Raises
+    ------
+    PowerIterationFailedConvergence
+        If the algorithm fails to converge to the specified tolerance
+        within the specified number of iterations of the power iteration
+        method.
+
+    References
+    ----------
+    .. [1] A. Langville and C. Meyer,
+       "A survey of eigenvector methods of web information retrieval."
+       http://citeseer.ist.psu.edu/713792.html
+    .. [2] Page, Lawrence; Brin, Sergey; Motwani, Rajeev and Winograd, Terry,
+       The PageRank citation ranking: Bringing order to the Web. 1999
+       http://dbpubs.stanford.edu:8090/pub/showDoc.Fulltext?lang=en&doc=1999-66&format=pdf
+    """
+    import scipy.sparse
+
+    t0 = time.time()
+    N = len(G)
+    if N == 0:
+        return {}
+    t1 = time.time()
+    print('t1 - t0', t1 - t0)
+
+    nodelist = list(G)
+    M = nx.to_scipy_sparse_matrix(G, nodelist=nodelist, weight=weight,
+                                  dtype=float)
+    S = scipy.array(M.sum(axis=1)).flatten()
+    S[S != 0] = 1.0 / S[S != 0]
+    Q = scipy.sparse.spdiags(S.T, 0, *M.shape, format='csr')
+    M = Q * M
+    t2 = time.time()
+    print('t2 - t1', t2 - t1)
+
+    # initial vector
+    x = scipy.repeat(1.0 / N, N)
+    t3 = time.time()
+    print('t3 - t2', t3 - t2)
+
+    # Personalization vector
+    if personalization is None:
+        p = scipy.repeat(1.0 / N, N)
+    else:
+        p = scipy.array([personalization.get(n, 0) for n in nodelist], dtype=float)
+        p = p / p.sum()
+    t4 = time.time()
+    print('t4 - t3', t4 - t3)
+
+    # Dangling nodes
+    if dangling is None:
+        dangling_weights = p
+    else:
+        # Convert the dangling dictionary into an array in nodelist order
+        dangling_weights = scipy.array([dangling.get(n, 0) for n in nodelist],
+                                       dtype=float)
+        dangling_weights /= dangling_weights.sum()
+    is_dangling = scipy.where(S == 0)[0]
+    t5 = time.time()
+    print('t5 - t4', t5 - t4)
+
+    # power iteration: make up to max_iter iterations
+    for i in range(max_iter):
+        xlast = x
+        x = alpha * (x * M + sum(x[is_dangling]) * dangling_weights) + \
+            (1 - alpha) * p
+        # check convergence, l1 norm
+        err = scipy.absolute(x - xlast).sum()
+        if err < N * tol:
+            t6 = time.time()
+            print('t6 - t5', t6 - t5)
+            result = dict(zip(nodelist, map(float, x)))
+            t7 = time.time()
+            print('t7 - t6', t7 - t6)
+            print('t7 - t0', t7 - t0)
+            print(i)
+            return result
+    raise nx.PowerIterationFailedConvergence(max_iter)
+
+
+# fixture for nose tests
+def setup_module(module):
+    from nose import SkipTest
+    try:
+        import numpy
+    except:
+        raise SkipTest("NumPy not available")
+    try:
+        import scipy
+    except:
+        raise SkipTest("SciPy not available")
+
+if __name__ == '__main__':
+    g = nx.read_graphml("pgp.xml")
+    pagerank_scipy(g, alpha=0.85, tol=1e-3, max_iter=10000000)

examples/profiling/pgp.sh

+wget https://graph-tool.skewed.de/static/performance/pgp.xml.gz
+gzip -d pgp.xml.gz

examples/profiling/profile.sh

+for lib in gt igraph nx dgl; do
+    echo "Profiling ${lib}"
+    python ${lib}_bench.py > ${lib}_bench
+    bash ${lib}_bench.sh
+done

examples/profiling/sp_bench.py

+#!/bin/env python
+from __future__ import print_function
+
+from networkx import *
+import cProfile
+
+g = read_graphml("pgp.xml")
+
+print("Profiling PageRank")
+print("==================")
+print()
+
+cProfile.run("for i in range(10): pagerank_scipy(g, alpha=0.85, tol=1e-3, max_iter=10000000)", sort="cumulative")

examples/profiling/sp_bench.sh

+echo "   ncalls  tottime  percall  cumtime  percall filename:lineno(function)"
+cat sp_bench | grep "pagerank_alg.py:338(pagerank_scipy)"

examples/profiling/tf_bench.py

+"""
+Adapted from code by Lingfan
+"""
+
+import argparse
+import cProfile
+import networkx as nx
+import tensorflow as tf
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--gpu', type=int, default=-1)
+args = parser.parse_args()
+
+g = nx.read_graphml('pgp.xml')
+n = g.number_of_nodes()
+adj = nx.adj_matrix(g).tocoo()
+indices = list(map(list, zip(adj.row, adj.col)))
+values = adj.data.astype('float32').tolist()
+
+device = '/cpu:0' if args.gpu < 0 else '/device:GPU:%d' %args.gpu
+with tf.device(device):
+    m = tf.SparseTensor(indices=indices, values=values, dense_shape=[n, n])
+session = tf.Session()
+
+def pagerank(alpha, tol, max_iter):
+    with tf.device(device):
+        p = tf.Variable(tf.constant(1.0 / n, shape=[n, 1]), trainable=False)
+        new_p = alpha * tf.sparse_tensor_dense_matmul(m, p) + (1 - alpha) / n
+        delta = tf.reduce_sum(tf.abs(new_p - p))
+        with tf.control_dependencies([delta]):
+            assignment = p.assign(new_p)
+
+    session.run(p.initializer)
+    for i in range(max_iter):
+        delta, _ = session.run([delta, assignment])
+        if delta < tol * n:
+            break
+
+print("Profiling PageRank")
+print("==================")
+print()
+
+# cProfile.run("for i in range(10): pagerank(alpha=0.85, tol=1e-3, max_iter=10000000)", sort="cumulative")
+
+import time
+t0 = time.time()
+for i in range(10):
+    pagerank(alpha=0.85, tol=1e-3, max_iter=10000000)
+print((time.time() - t0) / 10)

examples/profiling/tf_bench.sh

+echo "   ncalls  tottime  percall  cumtime  percall filename:lineno(function)"
+cat dgl_bench | grep "dgl_bench.py:25(pagerank)"

examples/profiling/th_bench.py

+import argparse
+import cProfile
+import networkx as nx
+import torch as th
+import utils
+
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--gpu', type=int, default=-1)
+args = parser.parse_args()
+
+
+if args.gpu < 0:
+    cuda = False
+    device = th.device('cpu')
+else:
+    cuda = True
+    th.cuda.set_device(args.gpu)
+    device = th.device(args.gpu)
+
+
+g = nx.read_graphml('pgp.xml')
+n = g.number_of_nodes()
+
+
+deg = g.out_degree()
+for (src, trg), attrs in g.edges.items():
+    attrs['weight'] = 1.0 / deg[src]
+adj = utils.sparse_sp2th(nx.adj_matrix(g))
+if cuda:
+    adj = adj.cuda()
+
+
+def pagerank(alpha, tol, max_iter):
+    pr = th.full((n, 1), 1 / n, device=device)
+    for i in range(max_iter):
+        next_pr = (1 - alpha) / n + alpha * th.mm(adj, pr)
+        if th.sum(th.abs(next_pr - pr)) < tol * n:
+            break
+    return next_pr
+
+
+for i in range(10):
+    pagerank(alpha=0.85, tol=1e-3, max_iter=10000000)
+
+
+print("Profiling PageRank")
+print("==================")
+print()
+
+
+# cProfile.run("for i in range(10): pagerank(alpha=0.85, tol=1e-3, max_iter=10000000)", sort="cumulative")
+
+
+import time
+t0 = time.time()
+for i in range(10):
+    pagerank(alpha=0.85, tol=1e-3, max_iter=10000000)
+print((time.time() - t0) / 10)

examples/profiling/utils.py

+import torch as th
+
+
+def sparse_sp2th(matrix):
+    coo = matrix.tocoo()
+    rows = th.from_numpy(coo.row).long().view(1, -1)
+    cols = th.from_numpy(coo.col).long().view(1, -1)
+    data = th.from_numpy(coo.data).float()
+    return th.sparse.FloatTensor(th.cat((rows, cols), 0), data, coo.shape)