344 lines
11 KiB
Python
344 lines
11 KiB
Python
# coding=utf8
|
||
# Copyright (C) 2004-2019 by
|
||
# Aric Hagberg <hagberg@lanl.gov>
|
||
# Dan Schult <dschult@colgate.edu>
|
||
# Pieter Swart <swart@lanl.gov>
|
||
# All rights reserved.
|
||
# BSD license.
|
||
#
|
||
# Authors: Aric Hagberg (aric.hagberg@gmail.com)
|
||
# Pieter Swart (swart@lanl.gov)
|
||
# Sasha Gutfraind (ag362@cornell.edu)
|
||
# Vincent Gauthier (vgauthier@luxbulb.org)
|
||
"""Katz centrality."""
|
||
from math import sqrt
|
||
|
||
import networkx as nx
|
||
from networkx.utils import not_implemented_for
|
||
|
||
__all__ = ['katz_centrality', 'katz_centrality_numpy']
|
||
|
||
|
||
@not_implemented_for('multigraph')
|
||
def katz_centrality(G, alpha=0.1, beta=1.0, max_iter=1000, tol=1.0e-6,
|
||
nstart=None, normalized=True, weight=None):
|
||
r"""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
|
||
|
||
.. math::
|
||
|
||
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
|
||
|
||
.. math::
|
||
|
||
\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.
|
||
|
||
nstart : dictionary, optional
|
||
Starting value of Katz iteration for each node.
|
||
|
||
normalized : bool, optional (default=True)
|
||
If True normalize the resulting values.
|
||
|
||
weight : None or string, optional (default=None)
|
||
If None, all edge weights are considered equal.
|
||
Otherwise holds the name of the edge attribute used as weight.
|
||
|
||
Returns
|
||
-------
|
||
nodes : dictionary
|
||
Dictionary of nodes with Katz centrality as the value.
|
||
|
||
Raises
|
||
------
|
||
NetworkXError
|
||
If the parameter `beta` is not a scalar but lacks a value for at least
|
||
one node
|
||
|
||
PowerIterationFailedConvergence
|
||
If the algorithm fails to converge to the specified tolerance
|
||
within the specified number of iterations of the power iteration
|
||
method.
|
||
|
||
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)
|
||
>>> for n, c in sorted(centrality.items()):
|
||
... print("%d %0.2f" % (n, c))
|
||
0 0.37
|
||
1 0.60
|
||
2 0.60
|
||
3 0.37
|
||
|
||
See Also
|
||
--------
|
||
katz_centrality_numpy
|
||
eigenvector_centrality
|
||
eigenvector_centrality_numpy
|
||
pagerank
|
||
hits
|
||
|
||
Notes
|
||
-----
|
||
Katz centrality was introduced by [2]_.
|
||
|
||
This algorithm it uses the power method to find the eigenvector
|
||
corresponding to the largest eigenvalue of the adjacency matrix of ``G``.
|
||
The parameter ``alpha`` should be strictly less than the inverse of largest
|
||
eigenvalue of the adjacency matrix for the algorithm to converge.
|
||
You can use ``max(nx.adjacency_spectrum(G))`` to get $\lambda_{\max}$ the largest
|
||
eigenvalue of the adjacency matrix.
|
||
The iteration will stop after ``max_iter`` iterations or an error tolerance of
|
||
``number_of_nodes(G) * tol`` has been reached.
|
||
|
||
When $\alpha = 1/\lambda_{\max}$ and $\beta=0$, Katz centrality is the same
|
||
as eigenvector centrality.
|
||
|
||
For directed graphs this finds "left" eigenvectors which corresponds
|
||
to the in-edges in the graph. For out-edges Katz centrality
|
||
first reverse the graph with ``G.reverse()``.
|
||
|
||
References
|
||
----------
|
||
.. [1] Mark E. J. Newman:
|
||
Networks: An Introduction.
|
||
Oxford University Press, USA, 2010, p. 720.
|
||
.. [2] Leo Katz:
|
||
A New Status Index Derived from Sociometric Index.
|
||
Psychometrika 18(1):39–43, 1953
|
||
http://phya.snu.ac.kr/~dkim/PRL87278701.pdf
|
||
"""
|
||
if len(G) == 0:
|
||
return {}
|
||
|
||
nnodes = G.number_of_nodes()
|
||
|
||
if nstart is None:
|
||
# choose starting vector with entries of 0
|
||
x = dict([(n, 0) for n in G])
|
||
else:
|
||
x = nstart
|
||
|
||
try:
|
||
b = dict.fromkeys(G, float(beta))
|
||
except (TypeError, ValueError, AttributeError):
|
||
b = beta
|
||
if set(beta) != set(G):
|
||
raise nx.NetworkXError('beta dictionary '
|
||
'must have a value for every node')
|
||
|
||
# make up to max_iter iterations
|
||
for i in range(max_iter):
|
||
xlast = x
|
||
x = dict.fromkeys(xlast, 0)
|
||
# do the multiplication y^T = Alpha * x^T A - Beta
|
||
for n in x:
|
||
for nbr in G[n]:
|
||
x[nbr] += xlast[n] * G[n][nbr].get(weight, 1)
|
||
for n in x:
|
||
x[n] = alpha * x[n] + b[n]
|
||
|
||
# check convergence
|
||
err = sum([abs(x[n] - xlast[n]) for n in x])
|
||
if err < nnodes * tol:
|
||
if normalized:
|
||
# normalize vector
|
||
try:
|
||
s = 1.0 / sqrt(sum(v**2 for v in x.values()))
|
||
# this should never be zero?
|
||
except ZeroDivisionError:
|
||
s = 1.0
|
||
else:
|
||
s = 1
|
||
for n in x:
|
||
x[n] *= s
|
||
return x
|
||
raise nx.PowerIterationFailedConvergence(max_iter)
|
||
|
||
|
||
@not_implemented_for('multigraph')
|
||
def katz_centrality_numpy(G, alpha=0.1, beta=1.0, normalized=True,
|
||
weight=None):
|
||
r"""Compute the Katz centrality for 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
|
||
|
||
.. math::
|
||
|
||
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
|
||
|
||
.. math::
|
||
|
||
\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.
|
||
|
||
normalized : bool
|
||
If True normalize the resulting values.
|
||
|
||
weight : None or string, optional
|
||
If None, all edge weights are considered equal.
|
||
Otherwise holds the name of the edge attribute used as weight.
|
||
|
||
Returns
|
||
-------
|
||
nodes : dictionary
|
||
Dictionary of nodes with Katz centrality as the value.
|
||
|
||
Raises
|
||
------
|
||
NetworkXError
|
||
If the parameter `beta` is not a scalar but lacks a value for at least
|
||
one node
|
||
|
||
Examples
|
||
--------
|
||
>>> import math
|
||
>>> G = nx.path_graph(4)
|
||
>>> phi = (1 + math.sqrt(5)) / 2.0 # largest eigenvalue of adj matrix
|
||
>>> centrality = nx.katz_centrality_numpy(G, 1/phi)
|
||
>>> for n, c in sorted(centrality.items()):
|
||
... print("%d %0.2f" % (n, c))
|
||
0 0.37
|
||
1 0.60
|
||
2 0.60
|
||
3 0.37
|
||
|
||
See Also
|
||
--------
|
||
katz_centrality
|
||
eigenvector_centrality_numpy
|
||
eigenvector_centrality
|
||
pagerank
|
||
hits
|
||
|
||
Notes
|
||
-----
|
||
Katz centrality was introduced by [2]_.
|
||
|
||
This algorithm uses a direct linear solver to solve the above equation.
|
||
The parameter ``alpha`` should be strictly less than the inverse of largest
|
||
eigenvalue of the adjacency matrix for there to be a solution.
|
||
You can use ``max(nx.adjacency_spectrum(G))`` to get $\lambda_{\max}$ the largest
|
||
eigenvalue of the adjacency matrix.
|
||
|
||
When $\alpha = 1/\lambda_{\max}$ and $\beta=0$, Katz centrality is the same
|
||
as eigenvector centrality.
|
||
|
||
For directed graphs this finds "left" eigenvectors which corresponds
|
||
to the in-edges in the graph. For out-edges Katz centrality
|
||
first reverse the graph with ``G.reverse()``.
|
||
|
||
References
|
||
----------
|
||
.. [1] Mark E. J. Newman:
|
||
Networks: An Introduction.
|
||
Oxford University Press, USA, 2010, p. 720.
|
||
.. [2] Leo Katz:
|
||
A New Status Index Derived from Sociometric Index.
|
||
Psychometrika 18(1):39–43, 1953
|
||
http://phya.snu.ac.kr/~dkim/PRL87278701.pdf
|
||
"""
|
||
try:
|
||
import numpy as np
|
||
except ImportError:
|
||
raise ImportError('Requires NumPy: http://scipy.org/')
|
||
if len(G) == 0:
|
||
return {}
|
||
try:
|
||
nodelist = beta.keys()
|
||
if set(nodelist) != set(G):
|
||
raise nx.NetworkXError('beta dictionary '
|
||
'must have a value for every node')
|
||
b = np.array(list(beta.values()), dtype=float)
|
||
except AttributeError:
|
||
nodelist = list(G)
|
||
try:
|
||
b = np.ones((len(nodelist), 1)) * float(beta)
|
||
except (TypeError, ValueError, AttributeError):
|
||
raise nx.NetworkXError('beta must be a number')
|
||
|
||
A = nx.adj_matrix(G, nodelist=nodelist, weight=weight).todense().T
|
||
n = A.shape[0]
|
||
centrality = np.linalg.solve(np.eye(n, n) - (alpha * A), b)
|
||
if normalized:
|
||
norm = np.sign(sum(centrality)) * np.linalg.norm(centrality)
|
||
else:
|
||
norm = 1.0
|
||
centrality = dict(zip(nodelist, map(float, centrality / norm)))
|
||
return centrality
|
||
|
||
|
||
# fixture for pytest
|
||
def setup_module(module):
|
||
import pytest
|
||
numpy = pytest.importorskip('numpy')
|
||
scipy = pytest.importorskip('scipy')
|