def test_transform():
import math
graph = next(pg.load_datasets_graph(["graph5"]))
for _ in supported_backends():
r1 = pg.Normalize(pg.PageRank(), "sum").rank(graph)
r2 = pg.Transformer(pg.PageRank(), lambda x: x / pg.sum(x)).rank(graph)
assert pg.Mabs(r1)(r2) < pg.epsilon()
r1 = pg.Transformer(math.exp).transform(pg.PageRank()(graph))
r2 = pg.Transformer(pg.PageRank(), pg.exp).rank(graph)
assert pg.Mabs(r1)(r2) < pg.epsilon()
def test_quotient():
graph = next(pg.load_datasets_graph(["graph9"]))
for _ in supported_backends():
test_result = pg.PageRank(normalization='symmetric',
tol=max(1.E-9, pg.epsilon()),
use_quotient=True).rank(graph)
norm_result = pg.PageRank(normalization='symmetric',
tol=max(1.E-9, pg.epsilon()),
use_quotient=pg.Normalize("sum")).rank(graph)
assert pg.Mabs(test_result)(norm_result) < pg.epsilon()
def test_stream():
graph = next(pg.load_datasets_graph(["graph9"]))
for _ in supported_backends():
ranks1 = pg.Normalize(
pg.PageRank(0.85,
tol=pg.epsilon(),
max_iters=1000,
use_quotient=False)).rank(graph, {"A": 1})
ranks2 = pg.to_signal(graph, {"A": 1}) >> pg.PageRank(
0.85, tol=pg.epsilon(),
max_iters=1000) + pg.Tautology() >> pg.Normalize()
assert pg.Mabs(ranks1)(ranks2) < pg.epsilon()
def test_sequential():
graph = next(pg.load_datasets_graph(["graph5"]))
for _ in supported_backends():
prior = pg.to_signal(graph, {"A": 2})
posterior1 = pg.Normalize(pg.PageRank(), "range").rank(prior)
posterior2 = pg.Normalize("range")(pg.PageRank()(prior))
posterior3 = pg.Sequential(pg.PageRank(),
pg.Normalize("range")).rank(prior)
assert pg.sum(pg.abs(posterior1 - posterior2)) < pg.epsilon(
) # TODO: investigate when not exactly zero
assert pg.sum(pg.abs(posterior1 - posterior3)) < pg.epsilon(
) # TODO: investigate when not exactly zero
def test_filter_stream():
graph = next(pg.load_datasets_graph(["graph9"]))
for _ in supported_backends():
test_result = pg.Normalize(
pg.PageRank(normalization='symmetric',
tol=max(1.E-9, pg.epsilon()),
use_quotient=True)).rank(graph)
norm_result = pg.PageRank(tol=max(1.E-9, pg.epsilon())) \
+ pg.preprocessor(normalization='symmetric') \
+ pg.Normalize("sum") \
>> pg.Normalize() \
| pg.to_signal(graph, {v: 1 for v in graph})
assert pg.Mabs(test_result)(norm_result) < pg.epsilon()
def test_absorbing_vs_pagerank():
graph = next(pg.load_datasets_graph(["graph9"]))
personalization = {"A": 1, "B": 1}
for _ in supported_backends():
pagerank_result = pg.PageRank(normalization='col').rank(graph, personalization)
absorbing_result = pg.AbsorbingWalks(0.85, normalization='col', max_iters=1000).rank(graph, personalization)
assert pg.Mabs(pagerank_result)(absorbing_result) < pg.epsilon()
def test_sweep_streaming():
_, graph, group = next(pg.load_datasets_one_community(["bigraph"]))
for _ in supported_backends():
training, evaluation = pg.split(list(group), training_samples=0.1)
auc1 = pg.AUC({v: 1
for v in evaluation}, exclude=training).evaluate(
(pg.PageRank() >> pg.Sweep()).rank(
graph, {v: 1
for v in training}))
auc2 = pg.AUC({v: 1
for v in evaluation},
exclude=training).evaluate(pg.PageRank().rank(
graph, {v: 1
for v in training}))
auc3 = pg.AUC(
{v: 1
for v in evaluation}, exclude=training).evaluate(
pg.PageRank() >> pg.Transformer(pg.log) >> pg.LinearSweep()
| pg.to_signal(graph, {v: 1
for v in training}))
assert auc1 > auc2
assert abs(auc1 - auc3) < pg.epsilon()
with pytest.raises(Exception):
pg.Sweep() << "a"
def test_separate_normalization():
graph = next(pg.load_datasets_graph(["graph5"]))
for _ in supported_backends():
algorithm = pg.PageRank(
preserve_norm=False) + pg.SeparateNormalization(["A", "B"])
ranks = algorithm(graph, {"A": 2})
assert abs(ranks["A"] + ranks["B"] - 1) < pg.epsilon()
def test_norm_maintain():
# TODO: investigate that 2.5*epsilon is truly something to be expected
graph = next(pg.load_datasets_graph(["graph5"]))
for _ in supported_backends():
prior = pg.to_signal(graph, {"A": 2})
posterior = pg.MabsMaintain(pg.Normalize(pg.PageRank(),
"range")).rank(prior)
assert abs(pg.sum(pg.abs(posterior.np)) - 2) < 2.5 * pg.epsilon()
def test_custom_runs():
graph = next(pg.load_datasets_graph(["graph9"]))
for _ in supported_backends():
ranks1 = pg.Normalize(
pg.PageRank(0.85,
tol=pg.epsilon(),
max_iters=1000,
use_quotient=False)).rank(graph, {"A": 1})
ranks2 = pg.Normalize(
pg.GenericGraphFilter([0.85**i * len(graph) for i in range(80)],
tol=pg.epsilon())).rank(graph, {"A": 1})
ranks3 = pg.Normalize(
pg.LowPassRecursiveGraphFilter([0.85 for _ in range(80)],
tol=pg.epsilon())).rank(
graph, {"A": 1})
assert pg.Mabs(ranks1)(ranks2) < 1.E-6
assert pg.Mabs(ranks1)(ranks3) < 1.E-6
def test_pagerank_vs_networkx():
graph = next(pg.load_datasets_graph(["graph9"]))
for _ in supported_backends():
ranker = pg.Normalize("sum", pg.PageRank(normalization='col', tol=1.E-9))
test_result = ranker(graph)
test_result2 = nx.pagerank(graph, tol=1.E-9)
# TODO: assert that 2.5*epsilon is indeed a valid limit
assert pg.Mabs(test_result)(test_result2) < 2.5*pg.epsilon()
def test_stream_diff():
graph = next(pg.load_datasets_graph(["graph9"]))
for _ in supported_backends():
ranks1 = pg.GenericGraphFilter(
[0, 0, 1], max_iters=4, error_type="iters") | pg.to_signal(
graph, {"A": 1})
ranks2 = pg.GenericGraphFilter(
[1, 1, 1], tol=None) & ~pg.GenericGraphFilter(
[1, 1], tol=None) | pg.to_signal(graph, {"A": 1})
assert pg.Mabs(ranks1)(ranks2) < pg.epsilon()
def test_automatic_graph_casting():
graph = next(pg.load_datasets_graph(["graph9"]))
for _ in supported_backends():
signal = pg.to_signal(graph, {"A": 1})
test_result1 = pg.PageRank(normalization='col').rank(signal, signal)
test_result2 = pg.PageRank(normalization='col').rank(personalization=signal)
assert pg.Mabs(test_result1)(test_result2) < pg.epsilon()
with pytest.raises(Exception):
pg.PageRank(normalization='col').rank(personalization={"A": 1})
with pytest.raises(Exception):
pg.PageRank(normalization='col').rank(graph.copy(), signal)
def test_pagerank_vs_networkx():
graph = next(pg.load_datasets_graph(["graph9"], graph_api=nx))
graph = graph.to_directed()
# graph_api needed so that nx.pagerank can perform internal computations
for _ in supported_backends():
ranker = pg.Normalize("sum", pg.PageRank(normalization='col'))
test_result2 = nx.pagerank(graph)
test_result = ranker(graph)
print(test_result)
print(test_result2)
# TODO: assert that 2.5*epsilon is indeed a valid limit
assert pg.Mabs(test_result)(test_result2) < 2.5 * pg.epsilon()
def test_normalize():
import networkx as nx
graph = next(pg.load_datasets_graph(["graph5"]))
for _ in supported_backends():
assert float(
pg.sum(
pg.Normalize("range").transform(
pg.to_signal(nx.Graph([("A", "B")]), [2, 2])).np)) == 4
r = pg.Normalize(pg.PageRank(), "range").rank(graph)
assert pg.min(r.np) == 0
assert pg.max(r.np) == 1
r = pg.Normalize(pg.PageRank(), "sum").rank(graph)
assert abs(pg.sum(r.np) - 1) < pg.epsilon()
with pytest.raises(Exception):
pg.Normalize(pg.PageRank(), "unknown").rank(graph)
def test_preprocessor_types():
def test_graph():
return next(pg.load_datasets_graph(["graph5"]))
for _ in supported_backends():
from random import random
graph = test_graph()
signal = pg.to_signal(graph, {v: random() for v in graph})
laplacian = pg.preprocessor(normalization="laplacian")(graph)
symmetric = pg.preprocessor(normalization="symmetric")(graph)
assert pg.abs(pg.sum(pg.conv(signal, laplacian) + pg.conv(signal, symmetric) - signal)) <= pg.epsilon()
