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()