def test_dict_to_numpy_array_a(self):
d = {'a': {'a': 1, 'b': 2}, 'b': {'a': 10, 'b': 20}}
mapping = {'a': 0, 'b': 1}
a = dict_to_numpy_array(d, mapping=mapping)
assert_allclose(a, numpy.array([[1, 2], [10, 20]]))
mapping = {'a': 1, 'b': 0}
a = dict_to_numpy_array(d, mapping=mapping)
assert_allclose(a, numpy.array([[20, 10], [2, 1]]))
a = dict_to_numpy_array2(d)
assert_allclose(a.sum(), 33)
def test_dict_to_numpy_array_a(self):
d = {"a": {"a": 1, "b": 2}, "b": {"a": 10, "b": 20}}
mapping = {"a": 0, "b": 1}
a = dict_to_numpy_array(d, mapping=mapping)
np.testing.assert_allclose(a, np.array([[1, 2], [10, 20]]))
mapping = {"a": 1, "b": 0}
a = dict_to_numpy_array(d, mapping=mapping)
np.testing.assert_allclose(a, np.array([[20, 10], [2, 1]]))
a = dict_to_numpy_array2(d)
np.testing.assert_allclose(a.sum(), 33)
def numeric_mixing_matrix(G, attribute, nodes=None, normalized=True):
"""Returns numeric mixing matrix for attribute.
The attribute must be an integer.
Parameters
----------
G : graph
NetworkX graph object.
attribute : string
Node attribute key. The corresponding attribute must be an integer.
nodes: list or iterable (optional)
Build the matrix only with nodes in container. The default is all nodes.
normalized : bool (default=True)
Return counts if False or probabilities if True.
Returns
-------
m: numpy array
Counts, or joint, probability of occurrence of node attribute pairs.
"""
d = attribute_mixing_dict(G, attribute, nodes)
s = set(d.keys())
for k, v in d.items():
s.update(v.keys())
m = max(s)
mapping = {x: x for x in range(m + 1)}
a = dict_to_numpy_array(d, mapping=mapping)
if normalized:
a = a / a.sum()
return a
def attribute_mixing_matrix(G, attribute, nodes=None, mapping=None,
normalized=True):
"""Return mixing matrix for attribute.
Parameters
----------
G : graph
NetworkX graph object.
attribute : string
Node attribute key.
nodes: list or iterable (optional)
Use only nodes in container to build the matrix. The default is
all nodes.
mapping : dictionary, optional
Mapping from node attribute to integer index in matrix.
If not specified, an arbitrary ordering will be used.
normalized : bool (default=True)
Return counts if False or probabilities if True.
Returns
-------
m: numpy array
Counts or joint probability of occurrence of attribute pairs.
"""
d = attribute_mixing_dict(G, attribute, nodes)
a = dict_to_numpy_array(d, mapping=mapping)
if normalized:
a = a / a.sum()
return a
def attribute_mixing_matrix(G, attribute, nodes=None, mapping=None,
normalized=True):
"""Return mixing matrix for attribute.
Parameters
----------
G : graph
NetworkX graph object.
attribute : string
Node attribute key.
nodes: list or iterable (optional)
Use only nodes in container to build the matrix. The default is
all nodes.
mapping : dictionary, optional
Mapping from node attribute to integer index in matrix.
If not specified, an arbitrary ordering will be used.
normalized : bool (default=True)
Return counts if False or probabilities if True.
Returns
-------
m: numpy array
Counts or joint probability of occurrence of attribute pairs.
"""
d = attribute_mixing_dict(G, attribute, nodes)
a = dict_to_numpy_array(d, mapping=mapping)
if normalized:
a = a / a.sum()
return a
def numeric_mixing_matrix(G, attribute, nodes=None, normalized=True):
"""Return numeric mixing matrix for attribute.
The attribute must be an integer.
Parameters
----------
G : graph
NetworkX graph object.
attribute : string
Node attribute key. The corresponding attribute must be an integer.
nodes: list or iterable (optional)
Build the matrix only with nodes in container. The default is all nodes.
normalized : bool (default=True)
Return counts if False or probabilities if True.
Returns
-------
m: numpy array
Counts, or joint, probability of occurrence of node attribute pairs.
"""
d = attribute_mixing_dict(G, attribute, nodes)
s = set(d.keys())
for k, v in d.items():
s.update(v.keys())
m = max(s)
mapping = {x: x for x in range(m + 1)}
a = dict_to_numpy_array(d, mapping=mapping)
if normalized:
a = a / a.sum()
return a
def test_dict_to_numpy_array_b(self):
d = {'a': 1, 'b': 2}
mapping = {'a': 0, 'b': 1}
a = dict_to_numpy_array(d, mapping=mapping)
assert_allclose(a, numpy.array([1, 2]))
a = dict_to_numpy_array1(d)
assert_allclose(a.sum(), 3)
def test_dict_to_numpy_array_b(self):
d = {"a": 1, "b": 2}
mapping = {"a": 0, "b": 1}
a = dict_to_numpy_array(d, mapping=mapping)
np.testing.assert_allclose(a, np.array([1, 2]))
a = dict_to_numpy_array1(d)
np.testing.assert_allclose(a.sum(), 3)
def degree_mixing_matrix(G,
x='out',
y='in',
weight=None,
nodes=None,
normalized=True):
"""Returns mixing matrix for attribute.
Parameters
----------
G : graph
NetworkX graph object.
x: string ('in','out')
The degree type for source node (directed graphs only).
y: string ('in','out')
The degree type for target node (directed graphs only).
nodes: list or iterable (optional)
Build the matrix using only nodes in container.
The default is all nodes.
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.
The degree is the sum of the edge weights adjacent to the node.
normalized : bool (default=True)
Return counts if False or probabilities if True.
Returns
-------
m: numpy array
Counts, or joint probability, of occurrence of node degree.
"""
d = degree_mixing_dict(G, x=x, y=y, nodes=nodes, weight=weight)
s = set(d.keys())
for k, v in d.items():
s.update(v.keys())
m = max(s)
mapping = {x: x for x in range(m + 1)}
a = dict_to_numpy_array(d, mapping=mapping)
if normalized:
a = a / a.sum()
return a
def degree_mixing_matrix(G, x='out', y='in', weight=None,
nodes=None, normalized=True):
"""Return mixing matrix for attribute.
Parameters
----------
G : graph
NetworkX graph object.
x: string ('in','out')
The degree type for source node (directed graphs only).
y: string ('in','out')
The degree type for target node (directed graphs only).
nodes: list or iterable (optional)
Build the matrix using only nodes in container.
The default is all nodes.
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.
The degree is the sum of the edge weights adjacent to the node.
normalized : bool (default=True)
Return counts if False or probabilities if True.
Returns
-------
m: numpy array
Counts, or joint probability, of occurrence of node degree.
"""
d = degree_mixing_dict(G, x=x, y=y, nodes=nodes, weight=weight)
s = set(d.keys())
for k, v in d.items():
s.update(v.keys())
m = max(s)
mapping = {x: x for x in range(m + 1)}
a = dict_to_numpy_array(d, mapping=mapping)
if normalized:
a = a / a.sum()
return a
def categorical_attribute_correlation_iter(xy_iter, categories=[]):
M_dict = mixing_dict(xy_iter)
# NB: must count all categories
for c in categories:
if c not in M_dict:
M_dict[c] = {}
# convert it to numpy array
M = dict_to_numpy_array(M_dict)
# must have at least 2 observations
if M.sum() < 2:
return None
corr = attribute_ac(M)
if np.isnan(corr):
return None
return corr
def attribute_mixing_matrix(G,
attribute,
nodes=None,
mapping=None,
normalized=True):
"""Returns mixing matrix for attribute.
Parameters
----------
G : graph
NetworkX graph object.
attribute : string
Node attribute key.
nodes: list or iterable (optional)
Use only nodes in container to build the matrix. The default is
all nodes.
mapping : dictionary, optional
Mapping from node attribute to integer index in matrix.
If not specified, an arbitrary ordering will be used.
normalized : bool (default=True)
Return counts if False or probabilities if True.
Returns
-------
m: numpy array
Counts or joint probability of occurrence of attribute pairs.
Notes
-----
If each node has a unique attribute value, the unnormalized mixing matrix
will be equal to the adjacency matrix. To get a denser mixing matrix,
the rounding can be performed to form groups of nodes with equal values.
For example, the exact height of persons in cm (180.79155222, 163.9080892,
163.30095355, 167.99016217, 168.21590163, ...) can be rounded to (180, 163,
163, 168, 168, ...).
Definitions of attribute mixing matrix vary on whether the matrix
should include rows for attribute values that don't arise. Here we
do not include such empty-rows. But you can force them to appear
by inputting a `mapping` that includes those values.
Examples
--------
>>> G = nx.path_graph(3)
>>> gender = {0: 'male', 1: 'female', 2: 'female'}
>>> nx.set_node_attributes(G, gender, 'gender')
>>> mapping = {'male': 0, 'female': 1}
>>> mix_mat = nx.attribute_mixing_matrix(G, 'gender', mapping=mapping)
>>> # mixing from male nodes to female nodes
>>> mix_mat[mapping['male'], mapping['female']]
0.25
"""
d = attribute_mixing_dict(G, attribute, nodes)
a = dict_to_numpy_array(d, mapping=mapping)
if normalized:
a = a / a.sum()
return a
def degree_mixing_matrix(G,
x="out",
y="in",
weight=None,
nodes=None,
normalized=True,
mapping=None):
"""Returns mixing matrix for attribute.
Parameters
----------
G : graph
NetworkX graph object.
x: string ('in','out')
The degree type for source node (directed graphs only).
y: string ('in','out')
The degree type for target node (directed graphs only).
nodes: list or iterable (optional)
Build the matrix using only nodes in container.
The default is all nodes.
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.
The degree is the sum of the edge weights adjacent to the node.
normalized : bool (default=True)
Return counts if False or probabilities if True.
mapping : dictionary, optional
Mapping from node degree to integer index in matrix.
If not specified, an arbitrary ordering will be used.
Returns
-------
m: numpy array
Counts, or joint probability, of occurrence of node degree.
Notes
-----
Definitions of degree mixing matrix vary on whether the matrix
should include rows for degree values that don't arise. Here we
do not include such empty-rows. But you can force them to appear
by inputting a `mapping` that includes those values. See examples.
Examples
--------
>>> G = nx.star_graph(3)
>>> mix_mat = nx.degree_mixing_matrix(G)
>>> mix_mat[0, 1] # mixing from node degree 1 to node degree 3
0.5
If you want every possible degree to appear as a row, even if no nodes
have that degree, use `mapping` as follows,
>>> max_degree = max(deg for n, deg in G.degree)
>>> mapping = {x: x for x in range(max_degree + 1)} # identity mapping
>>> mix_mat = nx.degree_mixing_matrix(G, mapping=mapping)
>>> mix_mat[3, 1] # mixing from node degree 3 to node degree 1
0.5
"""
d = degree_mixing_dict(G, x=x, y=y, nodes=nodes, weight=weight)
a = dict_to_numpy_array(d, mapping=mapping)
if normalized:
a = a / a.sum()
return a
