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]]