Builtin algorithms

graphscope.nx.builtin.hits(G, max_iter=100, tol=1e-08, normalized=True)

Returns HITS hubs and authorities values for nodes.

The HITS algorithm computes two numbers for a node. Authorities estimates the node value based on the incoming links. Hubs estimates the node value based on outgoing links.

Parameters

G (graph) – A networkx graph
max_iter (integer, optional) – Maximum number of iterations in power method.
tol (float, optional) – Error tolerance used to check convergence in power method iteration.
normalized (bool (default=True)) – Normalize results by the sum of all of the values.

Returns

(node, hubs,authorities) – node containing the hub and authority values.

Return type

three-column of dataframe

Examples

>>> G = nx.path_graph(4)
>>> nx.hits(G)

References

1: A. Langville and C. Meyer, “A survey of eigenvector methods of web information retrieval.” http://citeseer.ist.psu.edu/713792.html
2: Jon Kleinberg, Authoritative sources in a hyperlinked environment Journal of the ACM 46 (5): 604-32, 1999. doi:10.1145/324133.324140. http://www.cs.cornell.edu/home/kleinber/auth.pdf.

graphscope.nx.builtin.degree_centrality(G)

Compute the degree centrality for nodes.

The degree centrality for a node v is the fraction of nodes it is connected to.

Parameters: G (graph) – A networkx graph
Returns: nodes – Dataframe of nodes with degree centrality as the value.
Return type: dataframe

See also

eigenvector_centrality

Notes

The degree centrality values are normalized by dividing by the maximum possible degree in a simple graph n-1 where n is the number of nodes in G.

graphscope.nx.builtin.in_degree_centrality(G)

Compute the in-degree centrality for nodes.

The in-degree centrality for a node v is the fraction of nodes its incoming edges are connected to.

Parameters: G (graph) – A networkx graph
Returns: nodes – Dataframe of nodes with in-degree centrality as values.
Return type: dataframe
Raises: NetworkXNotImplemented – If G is undirected.

Notes

The degree centrality values are normalized by dividing by the maximum possible degree in a simple graph n-1 where n is the number of nodes in G.

graphscope.nx.builtin.out_degree_centrality(G)

Compute the out-degree centrality for nodes.

The out-degree centrality for a node v is the fraction of nodes its outgoing edges are connected to.

Parameters: G (graph) – A networkx graph
Returns: nodes – Dataframe of nodes with out-degree centrality as values.
Return type: dataframe
Raises: NetworkXNotImplemented – If G is undirected.

Notes

The degree centrality values are normalized by dividing by the maximum possible degree in a simple graph n-1 where n is the number of nodes in G.

graphscope.nx.builtin.eigenvector_centrality(G, max_iter=100, tol=1e-06, weight=None)

Compute the eigenvector centrality for the graph G.

Eigenvector centrality computes the centrality for a node based on the centrality of its neighbors. The eigenvector centrality for node $i$ is the $i$-th element of the vector $x$ defined by the equation

\[Ax = \lambda x\]

where $A$ is the adjacency matrix of the graph G with eigenvalue $lambda$. By virtue of the Perron–Frobenius theorem, there is a unique solution $x$, all of whose entries are positive, if $lambda$ is the largest eigenvalue of the adjacency matrix $A$ ([2]_).

Parameters

G (graph) – A networkx graph
max_iter (integer, optional (default=100)) – Maximum number of iterations in power method.
tol (float, optional (default=1.0e-6)) – Error tolerance used to check convergence in power method iteration.
weight (None or string, optional (default=None)) – If None, that take it as edge attribute ‘weight’ Otherwise holds the name of the edge attribute used as weight.

Returns

nodes – Dataframe of nodes with eigenvector centrality as the value.

Return type

dataframe

Examples

>>> G = nx.path_graph(4)
>>> centrality = nx.eigenvector_centrality(G)

See also

eigenvector_centrality_numpy, hits

graphscope.nx.builtin.katz_centrality(G, alpha=0.1, beta=1.0, max_iter=100, tol=1e-06, normalized=True, weight=None)

Compute the Katz centrality for the nodes of the graph G.

Katz centrality computes the centrality for a node based on the centrality of its neighbors. It is a generalization of the eigenvector centrality. The Katz centrality for node $i$ is

\[x_i = \alpha \sum_{j} A_{ij} x_j + \beta,\]

where $A$ is the adjacency matrix of graph G with eigenvalues $lambda$.

The parameter $beta$ controls the initial centrality and

\[\alpha < \frac{1}{\lambda_{\max}}.\]

Katz centrality computes the relative influence of a node within a network by measuring the number of the immediate neighbors (first degree nodes) and also all other nodes in the network that connect to the node under consideration through these immediate neighbors.

Extra weight can be provided to immediate neighbors through the parameter $beta$. Connections made with distant neighbors are, however, penalized by an attenuation factor $alpha$ which should be strictly less than the inverse largest eigenvalue of the adjacency matrix in order for the Katz centrality to be computed correctly. More information is provided in [1]_.

Parameters

G (graph) – A networkx graph.
alpha (float) – Attenuation factor
beta (scalar or dictionary, optional (default=1.0)) – Weight attributed to the immediate neighborhood. If not a scalar, the dictionary must have an value for every node.
max_iter (integer, optional (default=1000)) – Maximum number of iterations in power method.
tol (float, optional (default=1.0e-6)) – Error tolerance used to check convergence in power method iteration.
normalized (bool, optional (default=True)) – If True normalize the resulting values.
weight (None or string, optional (default=None)) – If None, that take it as edge attribute ‘weight’. Otherwise holds the name of the edge attribute used as weight.

Returns

nodes – Dataframe of nodes with Katz centrality as the value.

Return type

dataframe

Examples

>>> import math
>>> G = nx.path_graph(4)
>>> phi = (1 + math.sqrt(5)) / 2.0  # largest eigenvalue of adj matrix
>>> centrality = nx.katz_centrality(G, 1 / phi - 0.01)

graphscope.nx.builtin.has_path(G, source, target)

Returns True if G has a path from source to target.

Parameters

G (networkx graph) –
source (node) – Starting node for path
target (node) – Ending node for path

graphscope.nx.builtin.average_shortest_path_length(G, weight=None)

Returns the average shortest path length.

The average shortest path length is

\[a =\sum_{s,t \in V}\]

rac{d(s, t)}{n(n-1)}

where V is the set of nodes in G, d(s, t) is the shortest path from s to t, and n is the number of nodes in G.

G : networkx graph

weightNone or string, optional (default = None)
If None, default take as ‘weight’. If a string, use this edge attribute as the edge weight.
>>> G = nx.path_graph(5)
>>> nx.average_shortest_path_length(G)
2.0

graphscope.nx.builtin.bfs_edges(G, source, depth_limit=None)

edges in a breadth-first-search starting at source.

Parameters

G (networkx graph) –
source (node) – Specify starting node for breadth-first search; this function iterates over only those edges in the component reachable from this node.
depth_limit (int, optional(default=len(G))) – Specify the maximum search depth

Returns

edges – A list of edges in the breadth-first-search.

Return type

list

Examples

To get the edges in a breadth-first search:

>>> G = nx.path_graph(3)
>>> list(nx.bfs_edges(G, 0))
[(0, 1), (1, 2)]
>>> list(nx.bfs_edges(G, source=0, depth_limit=1))
[(0, 1)]

graphscope.nx.builtin.k_core(G, k=None, core_number=None)

Returns the k-core of G.

A k-core is a maximal subgraph that contains nodes of degree k or more.

Parameters

G (networkx graph) – A graph or directed graph
k (int, optional) – The order of the core. If not specified return the main core.

Returns

:class:`VertexDataContext` (A context with each vertex assigned with a boolean:)
1 if the vertex satisfies k-core, otherwise 0.

References

1: An O(m) Algorithm for Cores Decomposition of Networks Vladimir Batagelj and Matjaz Zaversnik, 2003. https://arxiv.org/abs/cs.DS/0310049

graphscope.nx.builtin.clustering(G)

Compute the clustering coefficient for nodes.

For unweighted graphs, the clustering of a node $u$ is the fraction of possible triangles through that node that exist,

\[c_u = \frac{2 T(u)}{deg(u)(deg(u)-1)},\]

where $T(u)$ is the number of triangles through node $u$ and $deg(u)$ is the degree of $u$.

For weighted graphs, there are several ways to define clustering [1]_. the one used here is defined as the geometric average of the subgraph edge weights [2]_,

\[c_u = \frac{1}{deg(u)(deg(u)-1))} \sum_{vw} (\hat{w}_{uv} \hat{w}_{uw} \hat{w}_{vw})^{1/3}.\]

The edge weights $\hat{w}_{uv}$ are normalized by the maximum weight in the network $\hat{w}_{uv} = w_{uv}/\max(w)$.

The value of $c_u$ is assigned to 0 if $deg(u) < 2$.

For directed graphs, the clustering is similarly defined as the fraction of all possible directed triangles or geometric average of the subgraph edge weights for unweighted and weighted directed graph respectively 3.

\[c_u = \frac{1}{deg^{tot}(u)(deg^{tot}(u)-1) - 2deg^{\leftrightarrow}(u)} T(u),\]

where $T(u)$ is the number of directed triangles through node $u$, $deg^{tot}(u)$ is the sum of in degree and out degree of $u$ and $deg^{\leftrightarrow}(u)$ is the reciprocal degree of $u$.

Parameters: G (graph) –
Returns: out – Clustering coefficient at nodes
Return type: dataframe

Examples

>>> G = nx.path_graph(5)
>>>nx.clustering(G)

References

1: Generalizations of the clustering coefficient to weighted complex networks by J. Saramäki, M. Kivelä, J.-P. Onnela, K. Kaski, and J. Kertész, Physical Review E, 75 027105 (2007). http://jponnela.com/web_documents/a9.pdf
2: Intensity and coherence of motifs in weighted complex networks by J. P. Onnela, J. Saramäki, J. Kertész, and K. Kaski, Physical Review E, 71(6), 065103 (2005).
3: Clustering in complex directed networks by G. Fagiolo, Physical Review E, 76(2), 026107 (2007).

graphscope.nx.builtin.triangles(G, nodes=None)

Compute the number of triangles.

Finds the number of triangles that include a node as one vertex.

Parameters: G (graph) – A networkx graph
Returns: out – Number of triangles keyed by node label.
Return type: dataframe

Notes

When computing triangles for the entire graph each triangle is counted three times, once at each node. Self loops are ignored.

graphscope.nx.builtin.average_clustering(G, nodes=None, count_zeros=True)

Compute the average clustering coefficient for the graph G.

The clustering coefficient for the graph is the average,

\[C = \frac{1}{n}\sum_{v \in G} c_v,\]

where $n$ is the number of nodes in G.

Parameters

G (graph) –
nodes (container of nodes, optional (default=all nodes in G)) – Compute average clustering for nodes in this container.
weight (string or None, optional (default=None)) – The edge attribute that holds the numerical value used as a weight. If None, then each edge has weight 1.
count_zeros (bool) – If False include only the nodes with nonzero clustering in the average.

Returns

avg – Average clustering

Return type

float

Examples

>>> G = nx.complete_graph(5)
>>> print(nx.average_clustering(G))
1.0

Notes

This is a space saving routine; it might be faster to use the clustering function to get a list and then take the average.

Self loops are ignored.

References

1: Generalizations of the clustering coefficient to weighted complex networks by J. Saramäki, M. Kivelä, J.-P. Onnela, K. Kaski, and J. Kertész, Physical Review E, 75 027105 (2007). http://jponnela.com/web_documents/a9.pdf
2: Marcus Kaiser, Mean clustering coefficients: the role of isolated nodes and leafs on clustering measures for small-world networks. https://arxiv.org/abs/0802.2512