def test_possible_paths():
"""Test to generate all possible paths."""
paths = PathCollection()
paths.add('a', 'a', 'b', 'b', 'a')
null = NullModel()
assert len(null.possible_relations(paths, length=3)) == 16
def fit(self,
data: PathCollection,
max_order: Optional[int] = None,
null_models: bool = True) -> None:
"""Fit data to a MultiOrderModel"""
# Check max order
if max_order is not None:
self._max_order = max_order
# store data
self.data = data
for order in list(
range(self._current_max_order() + 1, self.max_order + 1)):
LOG.debug('Generating %s-th order layer ...', order)
# generate higher order network
_hon = HigherOrderNetwork.from_paths(data,
order=order,
subpaths=True)
# calculate transition matrices for the higher-order networks
_mat = _hon.transition_matrix(count=True, transposed=True)
_null = None
if null_models:
# generate null model
_null = NullModel.from_paths(data, order=order)
self.layers[order]['hon'] = _hon
self.layers[order]['T'] = _mat
self.layers[order]['null'] = _null
def test_degrees_of_reedom():
"""Tets degrees of freedom"""
paths = PathCollection()
paths.add('a', 'c', 'd', frequency=2)
paths.add('b', 'c', 'e', frequency=2)
null = NullModel.from_paths(paths, order=0)
assert null.degrees_of_freedom() == 4
null = NullModel.from_paths(paths, order=1)
assert null.degrees_of_freedom() == 1
null = NullModel.from_paths(paths, order=2)
assert null.degrees_of_freedom() == 2
null = NullModel.from_paths(paths, order=3)
assert null.degrees_of_freedom() == 0
def __init__(self, network, max_order=1):
"""Initialize multi-oder model."""
self.network = network
self.null = NullModel(self.network)
self.max_order = max_order
# initialize variables
self.layers = {}
self.null_models = {}
self.transition_matrices = {}
def test_from_network():
net = Network()
net.add_edge('a', 'c', count=10)
net.add_edge('c', 'd', count=10)
net.add_edge('b', 'c', count=10)
net.add_edge('c', 'e', count=10)
null = NullModel.from_network(net, order=2)
assert null.number_of_edges() == 4
assert null.number_of_nodes() == 4
for e in null.edges.uids:
assert null.edges.counter[e] == 5.0
def test_from_network():
net = Network()
net.add_edge('a', 'c', frequency=10)
net.add_edge('c', 'd', frequency=10)
net.add_edge('b', 'c', frequency=10)
net.add_edge('c', 'e', frequency=10)
null = NullModel.from_network(net, order=2)
assert null.number_of_edges() == 4
assert null.number_of_nodes() == 4
for e in null.edges:
assert e['frequency'] == 5.0
def test_basic():
"""Test basic functions"""
paths = PathCollection()
paths.add('a', 'c', 'd', uid='a-c-d', frequency=10)
paths.add('b', 'c', 'e', uid='b-c-e', frequency=10)
# null = NullModel()
# null.fit(paths, order=2)
null = NullModel.from_paths(paths, order=2)
assert null.number_of_edges() == 4
assert null.number_of_nodes() == 4
for e in null.edges:
assert e['frequency'] == 5.0
def degrees_of_freedom(self, order: int = 1, mode: str = 'path') -> int:
# TODO add checks for the max order
max_order = order
# initialize degrees of freedom
dof = 0
for order in range(0, max_order + 1):
# check if the null model for the given order is
# already calculated if not calculate new null model
if self.layers[order].get('null', None) is None:
self.layers[order]['null'] = NullModel.from_paths(self.data,
order=order)
dof += self.layers[order]['null'].degrees_of_freedom(mode=mode)
return dof
def test_possible_paths():
"""Test to generate all possible paths."""
paths = PathCollection()
paths.add('a', 'a', 'b', 'b', 'a')
assert len(NullModel.possible_paths(paths.edges, order=3)) == 16