def test_compare_values(default_plugin_resolver, capsys):
dpr = default_plugin_resolver
mv = MultiVerify(dpr)
nnm1 = NumpyNodeMap([1.1, 4.5], [0, 2])
nnm2 = NumpyNodeMap([1.1, 4.9], [0, 2])
pns = {0, 2}
with pytest.raises(TypeError, match="`val` must be"):
mv.compare_values(pns, nnm1, "testing.compare.values")
capsys.readouterr()
with pytest.raises(AssertionError):
mv.compare_values(nnm1, nnm2, "testing.compare.values")
captured = capsys.readouterr()
assert "val" in captured.out
assert "val.value" in captured.out
assert "expected_val" in captured.out
assert "expected_val.value" in captured.out
# Compare floats
mv.compare_values(1.1,
1.1 + 1e-9,
"testing.compare.values.floats",
rel_tol=1e-6)
# Compare ints
mv.compare_values(5, 5, "testing.compare.values.ints")
def test_nodemap_roundtrip(default_plugin_resolver):
rt = RoundTripper(default_plugin_resolver)
nodes = np.array([1, 2, 42, 99])
vals = np.array([12.5, 33.4, -1.2, 0.0])
rt.verify_round_trip(NumpyNodeMap(vals, nodes=nodes))
rt.verify_round_trip(NumpyNodeMap(vals.astype(int), nodes=nodes))
rt.verify_round_trip(NumpyNodeMap(vals.astype(bool), nodes=nodes))
def graph_from_networkx(x: NetworkXGraph, **props) -> ScipyGraph:
aprops = NetworkXGraph.Type.compute_abstract_properties(
x, {"node_type", "edge_type"})
ordered_nodes = list(sorted(x.value.nodes(
))) # TODO do we necesarily have to sort? Expensive for large inputs
is_sequential = ordered_nodes[-1] == len(ordered_nodes) - 1
if aprops["node_type"] == "map":
node_vals = np.array([
x.value.nodes[n].get(x.node_weight_label)
for n in ordered_nodes
])
if is_sequential:
nodes = NumpyNodeMap(node_vals)
else:
nodes = NumpyNodeMap(node_vals,
node_ids=np.array(ordered_nodes))
elif not is_sequential:
nodes = NumpyNodeSet(np.array(ordered_nodes))
else:
nodes = None
orphan_nodes = set(nx.isolates(x.value))
ordered_nodes = [n for n in ordered_nodes if n not in orphan_nodes]
if aprops["edge_type"] == "map":
m = nx.convert_matrix.to_scipy_sparse_matrix(
x.value,
nodelist=ordered_nodes,
weight=x.edge_weight_label,
)
edges = ScipyEdgeMap(m, ordered_nodes)
else:
m = nx.convert_matrix.to_scipy_sparse_matrix(
x.value, nodelist=ordered_nodes)
edges = ScipyEdgeSet(m, ordered_nodes)
return ScipyGraph(edges, nodes)
def karateclub_node2vec_train(
graph: NetworkXGraph,
p: float,
q: float,
walks_per_node: int,
walk_length: int,
embedding_size: int,
epochs: int,
learning_rate: float,
worker_count: int = 1,
) -> Tuple[NumpyMatrixType, NumpyNodeMap]:
trainer = karateclub.Node2Vec(
walk_number=walks_per_node,
walk_length=walk_length,
workers=worker_count,
p=p,
q=q,
dimensions=embedding_size,
epochs=epochs,
learning_rate=learning_rate,
)
old2canonical = {
node: canonical_index
for canonical_index, node in enumerate(graph.value.nodes)
}
relabelled_graph = nx.relabel_nodes(graph.value,
old2canonical,
copy=True)
trainer.fit(relabelled_graph)
np_embedding_matrix = trainer.get_embedding()
node2index = NumpyNodeMap(np.arange(len(graph.value.nodes)),
nodes=np.array(list(graph.value.nodes)))
return (np_embedding_matrix, node2index)
def test_np_nodemap_2_np_nodeset(default_plugin_resolver):
dpr = default_plugin_resolver
x = NumpyNodeMap(np.array([00, 10, 20]))
assert len(x) == 3
intermediate = NumpyNodeSet(np.array([0, 1, 2]))
y = dpr.translate(x, NumpyNodeSet)
dpr.assert_equal(y, intermediate)
def test_nodemap_nodeset_oneway(default_plugin_resolver):
rt = RoundTripper(default_plugin_resolver)
nodes = np.array([1, 2, 42, 99])
vals = np.array([12.5, 33.4, -1.2, 0.0])
start = NumpyNodeMap(vals, nodes=nodes)
end = NumpyNodeSet(nodes)
rt.verify_one_way(start, end)
def sg_graphwave_train(
graph: StellarGraph,
scales: NumpyVectorType,
sample_point_count: int,
sample_point_max: float,
chebyshev_degree: int,
) -> Tuple[NumpyMatrixType, NumpyNodeMap]:
sample_points = np.linspace(0, sample_point_max,
sample_point_count).astype(np.float32)
generator = sg.mapper.GraphWaveGenerator(graph.value,
scales=scales,
degree=chebyshev_degree)
nodes = graph.value.nodes().sort_values()
embeddings_dataset = generator.flow(
node_ids=nodes,
sample_points=sample_points,
batch_size=len(nodes),
shuffle=False,
repeat=False,
)
tf_tensor = list(embeddings_dataset)[
0] # TODO do we want a tensor matrix type?
np_matrix = tf_tensor.numpy()
node2index = NumpyNodeMap(np.arange(len(nodes)),
nodes=nodes.to_numpy())
return (np_matrix, node2index)
def test_numpy_compact():
NumpyNodeMap.Type.assert_equal(
NumpyNodeMap(np.array([1, 3, 5]), node_ids={0: 0, 240: 1, 968: 2}),
NumpyNodeMap(np.array([1, 3, 5]), node_ids=np.array([0, 240, 968])),
{},
{},
{},
{},
)
NumpyNodeMap.Type.assert_equal(
NumpyNodeMap(
np.array([1, 3, 5.5555555555555555555]), node_ids={0: 0, 1: 1, 2: 2}
),
NumpyNodeMap(
np.array([1, 3 + 1e-9, 5.5555555555555555556]), node_ids={0: 0, 1: 1, 2: 2}
),
{},
{},
{},
{},
)
with pytest.raises(AssertionError):
NumpyNodeMap.Type.assert_equal(
NumpyNodeMap(np.array([1, 3, 5]), node_ids={0: 0, 1: 1, 2: 2}),
NumpyNodeMap(np.array([1, 3, 5, 7]), node_ids={0: 0, 1: 1, 2: 2, 3: 3}),
{},
{},
{},
{},
)
# Non-monotonic
with pytest.raises(TypeError):
NumpyNodeMap(np.array([5, 1, 3]), node_ids=np.array([7, 0, 2])),
def test_cudf_node_map_to_numpy_node_map():
dpr = mg.resolver
keys = [3, 2, 1, 0]
values = [33, 22, 11, 00]
cudf_data = cudf.Series(values).set_index(keys)
x = dpr.wrappers.NodeMap.CuDFNodeMap(cudf_data)
intermediate = NumpyNodeMap(np.array([00, 11, 22, 33], dtype=int))
y = dpr.translate(x, NumpyNodeMap)
dpr.assert_equal(y, intermediate)
assert len(dpr.plan.translate(x, NumpyNodeMap)) == 1
def test_numpy_graphblas(default_plugin_resolver):
dpr = default_plugin_resolver
data = np.array([1, 1, 3, 1, 4, 1, -1])
missing = data == 1
x = NumpyNodeMap(data, mask=~missing)
assert x.num_nodes == 3
# Convert numpy -> graphblas
intermediate = GrblasNodeMap(
grblas.Vector.from_values([2, 4, 6], [3, 4, -1]), )
y = dpr.translate(x, GrblasNodeMap)
dpr.assert_equal(y, intermediate)
def test_python_2_numpy(default_plugin_resolver):
dpr = default_plugin_resolver
x = PythonNodeMap({0: 12.5, 1: 33.4, 42: -1.2})
assert x.num_nodes == 3
# Convert python -> numpy
intermediate = NumpyNodeMap(
np.array([12.5, 33.4, -1.2]),
node_ids={
0: 0,
1: 1,
42: 2
},
)
y = dpr.translate(x, NumpyNodeMap)
dpr.assert_equal(y, intermediate)
# Convert python <- numpy
x2 = dpr.translate(y, PythonNodeMap)
dpr.assert_equal(x, x2)
def test_numpy():
NumpyNodeMap.Type.assert_equal(
NumpyNodeMap(np.array([1, 3, 5, 7, 9])),
NumpyNodeMap(np.array([1, 3, 5, 7, 9])),
{},
{},
{},
{},
)
NumpyNodeMap.Type.assert_equal(
NumpyNodeMap(np.array([1, 3, 5.5555555555555555555, 7, 9])),
NumpyNodeMap(np.array([1, 3, 5.5555555555555555556, 7, 9 + 1e-9])),
{},
{},
{},
{},
)
with pytest.raises(AssertionError):
NumpyNodeMap.Type.assert_equal(
NumpyNodeMap(np.array([1, 3, 5, 7, 9])),
NumpyNodeMap(np.array([1, 3, 5, 7, 9, 11])),
{},
{},
{},
{},
)
# Missing value should not affect equality
NumpyNodeMap.Type.assert_equal(
NumpyNodeMap(
np.array([1, -1, -1, 4, 5, -1]),
mask=np.array([True, False, False, True, True, False]),
),
NumpyNodeMap(
np.array([1, 0, 0, 4, 5, 0]),
mask=np.array([True, False, False, True, True, False]),
),
{},
{},
{},
{},
)
def translate_nodes_cudfnodemap2numpynodemap(x: CuDFNodeMap,
**props) -> NumpyNodeMap:
return NumpyNodeMap(cupy.asnumpy(x.value.values),
nodes=cupy.asnumpy(x.value.index.to_array()))
def test_method_call_secondary(default_plugin_resolver):
dpr = default_plugin_resolver
with dpr:
x = NumpyNodeMap(np.array([12.5, 33.4, -1.2]), nodes=(0, 1, 42))
y = {0, 1, 42}
z = GrblasNodeSet(grblas.Vector.from_values([0, 1, 42], [1, 1, 1]))
z_other = GrblasNodeSet(grblas.Vector.from_values([0, 2], [1, 1]))
# Wrapper
dpr.assert_equal(x.translate(GrblasNodeSet), z)
dpr.assert_equal(x.translate(dpr.wrappers.NodeSet.GrblasNodeSet), z)
dpr.assert_equal(x.translate(mg.wrappers.NodeSet.GrblasNodeSet), z)
# ConcreteType
dpr.assert_equal(x.translate(GrblasNodeSet.Type), z)
dpr.assert_equal(x.translate(PythonNodeSetType), y)
dpr.assert_equal(x.translate(dpr.types.NodeSet.GrblasNodeSetType), z)
dpr.assert_equal(x.translate(mg.types.NodeSet.GrblasNodeSetType), z)
dpr.assert_equal(x.translate(mg.types.NodeSet.PythonNodeSetType), y)
# ConcreteType's value_type
dpr.assert_equal(x.translate(set), y)
# instance of Wrapper
dpr.assert_equal(x.translate(z_other), z)
# instance of ConcreteType's value_type
dpr.assert_equal(x.translate({"a", "b"}), y)
# string of Wrapper class name
dpr.assert_equal(x.translate("GrblasNodeSet"), z)
# string of ConcreteType class name
dpr.assert_equal(x.translate("PythonNodeSetType"), y)
dpr.assert_equal(x.translate("GrblasNodeSetType"), z)
epochs=epochs,
use_multiprocessing=False,
workers=worker_count,
shuffle=True,
)
nodes = graph.value.nodes().sort_values()
node_gen = sg.mapper.Node2VecNodeGenerator(graph.value,
batch_size).flow(nodes)
x_inp_src = x_inp[0]
x_out_src = x_out[0]
embedding_model = tf.keras.Model(inputs=x_inp_src, outputs=x_out_src)
node_embeddings = embedding_model.predict(node_gen,
workers=worker_count)
node2index = NumpyNodeMap(np.arange(len(nodes)),
nodes=nodes.to_numpy())
return (node_embeddings, node2index)
@concrete_algorithm("embedding.train.graphwave")
def sg_graphwave_train(
graph: StellarGraph,
scales: NumpyVectorType,
sample_point_count: int,
sample_point_max: float,
chebyshev_degree: int,
) -> Tuple[NumpyMatrixType, NumpyNodeMap]:
sample_points = np.linspace(0, sample_point_max,
sample_point_count).astype(np.float32)
generator = sg.mapper.GraphWaveGenerator(graph.value,
scales=scales,
def test_numpy():
NumpyNodeMap.Type.assert_equal(
NumpyNodeMap(np.array([1, 3, 5, 7, 9])),
NumpyNodeMap(np.array([1, 3, 5, 7, 9])),
{},
{},
{},
{},
)
NumpyNodeMap.Type.assert_equal(
NumpyNodeMap(np.array([1, 3, 5.5555555555555555555, 7, 9])),
NumpyNodeMap(np.array([1, 3, 5.5555555555555555556, 7, 9 + 1e-9])),
{},
{},
{},
{},
)
NumpyNodeMap.Type.assert_equal(
NumpyNodeMap(np.array([1, 3, 5, 7, 9]), [14, 2, 7, 8, 20]),
NumpyNodeMap(np.array([1, 3, 5, 7, 9]), [14, 2, 7, 8, 20]),
{},
{},
{},
{},
)
NumpyNodeMap.Type.assert_equal(
NumpyNodeMap(np.array([1, 3, 5, 7, 9]), [0, 2, 4, 6, 8]),
NumpyNodeMap.from_mask(
np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
np.array([True, False, True, False, True, False, True, False, True, False]),
),
{},
{},
{},
{},
)
with pytest.raises(AssertionError):
NumpyNodeMap.Type.assert_equal(
NumpyNodeMap(np.array([1, 3, 5, 7, 9])),
NumpyNodeMap(np.array([1, 3, 5, 7, 9, 11])),
{},
{},
{},
{},
)
with pytest.raises(AssertionError):
NumpyNodeMap.Type.assert_equal(
NumpyNodeMap(np.array([1, 3, 5, 7, 9]), np.array([14, 2, 7, 8, 20])),
NumpyNodeMap(np.array([1, 3, 5, 7, 9]), np.array([2, 7, 8, 14, 20])),
{},
{},
{},
{},
)
# Exercise NumpyNodeSet
with pytest.raises(TypeError, match="Invalid number of dimensions: 2"):
NumpyNodeSet(np.array([[1, 2, 3], [4, 5, 6]]))
with pytest.raises(TypeError, match="Invalid dtype for NodeSet"):
NumpyNodeSet(np.array([1.1, 2.2, 3.3]))
# Handle duplicates
x = NumpyNodeSet([1, 1, 3, 4, 1, 2, 1])
assert len(x) == 4
assert 1 in x
assert [2, 3, 4] in x
# Exercise NumpyNodeMap
with pytest.raises(TypeError, match="Invalid number of dimensions: 2"):
NumpyNodeMap(np.array([[1, 2, 3], [4, 5, 6]]))
with pytest.raises(TypeError, match="Nodes must be same shape and size as data"):
NumpyNodeMap([1, 2, 3, 4], nodes=[1, 2, 3])
with pytest.raises(TypeError, match="Invalid dtype for nodes"):
NumpyNodeMap([1, 2, 3, 4], nodes=[1.1, 2.2, 3.3, 4.4])
with pytest.raises(TypeError, match="Duplicate node ids found"):
NumpyNodeMap([1, 2, 3, 4], nodes=[1, 1, 1, 2])
y = NumpyNodeMap([1.1, 2.2, 3.3, 4.4], nodes=[5, 6, 7, 22])
assert len(y) == 4
assert 22 in y
assert [5, 6, 7] in y
assert y[5] == 1.1
with pytest.raises(KeyError, match="is not in the NodeMap"):
y[17]
with pytest.raises(KeyError, match="are not all in the NodeMap"):
y[[7, 8, 9]]
