average_neighbor_degree

average_neighbor_degree(G, source='out', target='out', nodes=None, weight=None)

Returns the average degree of the neighborhood of each node.

In an undirected graph, the neighborhood N(i) of node i contains the nodes that are connected to i by an edge.

For directed graphs, N(i) is defined according to the parameter source:

• if source is ‘in’, then N(i) consists of predecessors of node i.

• if source is ‘out’, then N(i) consists of successors of node i.

• if source is ‘in+out’, then N(i) is both predecessors and successors.

The average neighborhood degree of a node i is

\[k_{nn,i} = \frac{1}{|N(i)|} \sum_{j \in N(i)} k_j\]

where N(i) are the neighbors of node i and k_j is the degree of node j which belongs to N(i). For weighted graphs, an analogous measure can be defined [1],

\[k_{nn,i}^{w} = \frac{1}{s_i} \sum_{j \in N(i)} w_{ij} k_j\]

where s_i is the weighted degree of node i, w_{ij} is the weight of the edge that links i and j and N(i) are the neighbors of node i.

Parameters:

GNetworkX graph

sourcestring (“in”|”out”|”in+out”), optional (default=”out”)

Directed graphs only. Use “in”- or “out”-neighbors of source node.

targetstring (“in”|”out”|”in+out”), optional (default=”out”)

Directed graphs only. Use “in”- or “out”-degree for target node.

nodeslist or iterable, optional (default=G.nodes)

Compute neighbor degree only for specified nodes.

weightstring 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.

Returns:

d: dict

A dictionary keyed by node to the average degree of its neighbors.

Raises:

NetworkXError

If either source or target are not one of ‘in’, ‘out’, or ‘in+out’. If either source or target is passed for an undirected graph.

See also

average_degree_connectivity

References

[1]

A. Barrat, M. Barthélemy, R. Pastor-Satorras, and A. Vespignani, “The architecture of complex weighted networks”. PNAS 101 (11): 3747–3752 (2004).

Examples

>>> G = nx.path_graph(4)
>>> G.edges[0, 1]["weight"] = 5
>>> G.edges[2, 3]["weight"] = 3

>>> nx.average_neighbor_degree(G)
{0: 2.0, 1: 1.5, 2: 1.5, 3: 2.0}
>>> nx.average_neighbor_degree(G, weight="weight")
{0: 2.0, 1: 1.1666666666666667, 2: 1.25, 3: 2.0}

>>> G = nx.DiGraph()
>>> nx.add_path(G, [0, 1, 2, 3])
>>> nx.average_neighbor_degree(G, source="in", target="in")
{0: 0.0, 1: 0.0, 2: 1.0, 3: 1.0}

>>> nx.average_neighbor_degree(G, source="out", target="out")
{0: 1.0, 1: 1.0, 2: 0.0, 3: 0.0}
----

Additional backends implement this function

parallelA networkx backend that uses joblib to run graph algorithms in parallel. Find the nx-parallel’s configuration guide here

The nodes are chunked into node_chunks and then the average degree of the neighborhood of each node for all node_chunks is computed in parallel over n_jobs number of CPU cores.

Additional parameters:

get_chunksstr, function (default = “chunks”)

A function that takes in a list of all the nodes (or nbunch) as input and returns an iterable node_chunks. The default chunking is done by slicing the nodes into n_jobs number of chunks.

[Source]