mindspore_gl.sampling

查看源文件

图数据的采样API。

mindspore_gl.sampling.k_hop_subgraph(node_idx, num_hops, adj_coo, node_count, relabel_nodes=False, flow='source_to_target')[源代码]

HomoGraph上的K跳采样。

参数：

  • node_idx (int, list, tuple or numpy.ndarray) - 围绕 node_idx 采样子图。

  • num_hops (int) - 在子图上采样 num_hops 跳。

  • adj_coo (numpy.ndarray) - 输入图的邻接矩阵。

  • node_count (int) - 节点数。

  • relabel_nodes (bool) - 节点索引是否需要重新标签。默认值：False。

  • flow (str, 可选) - 访问方向。默认值：’source_to_target’。

    • ‘source_to_target’: 从源节点到目标节点。

    • ‘target_to_source’: 从目标节点到源节点。

返回：

res(dict)，有4个键“subset”、“ad_coo”、“inv”、“edge_mask”，其中，

  • subset (numpy.ndarray) - 采样K跳的子图节点idx。

  • ad_coo (numpy.ndarray) - 采样K跳的子图邻接矩阵。

  • inv (list) - 从 node_idx 中的节点索引到其新位置的映射。

  • edge_mask (numpy.array) - 边掩码，指示保留哪些边。

异常：

  • TypeError - 如果 num_hops 或 num_hops 不是正整数。

  • TypeError - 如果 num_hops 不是bool。

  • ValueError - 如果 flow 不是source_to_target或target_to_source。

支持平台：

Ascend GPU

样例：

>>> from mindspore_gl.graph import MindHomoGraph
>>>from mindspore_gl.sampling import k_hop_subgraph
>>> graph = MindHomoGraph()
>>> coo_array = np.array([[0, 1, 1, 2, 3, 0, 3, 4, 2, 5],
...                       [1, 0, 2, 1, 0, 3, 4, 3, 5, 2]])
>>> graph.set_topo_coo(coo_array)
>>> graph.node_count = 6
>>> graph.edge_count = 10
>>> res = k_hop_subgraph([0, 3], 2, graph.adj_coo, graph.node_count,
... relabel_nodes=True)
>>> print(res)
{'subset': array([0, 1, 2, 3, 4]), 'adj_coo': array([[0, 1, 1, 2, 3, 0, 3, 4],
[1, 0, 2, 1, 0, 3, 4, 3]]), 'inv': array([0, 3]), 'edge_mask': array([ True,  True,  True,  True,  True,  True,
True,  True, False, False])}
mindspore_gl.sampling.negative_sample(positive, node, num_neg_samples, mode='undirected', re='more')[源代码]

输入所有正样本边集，并指定负样本长度。 然后返回相同长度的负样本边集，并且不会重复正样本。 可以选择考虑自循环、有向图或无向图操作。

参数：

  • positive (list or numpy.ndarray) - 所有正样本边。

  • node (int) - 节点数。

  • num_neg_samples (int) - 负样本长度。

  • mode (str, 可选) - 运算矩阵的类型。默认值：’undirected’。

    • undirected: 无向图。

    • bipartite: 二部图。

    • other: 其他类型图。

  • re (str, 可选) - 输入数据类型。默认值：’more’。

    • more: positive 数组shape为 \((data\_length, 2)\) 。

    • other: positive 数组shape为 \((2, data\_length)\) 。

返回：

数组，负采样边集，shape为 \((num\_neg\_samples, 2)\)

异常：

  • TypeError - 如果 positive 不是List或numpy.ndarry。

  • TypeError - 如果 node 不是正整数。

  • TypeError - 如果 re 不在”more”或”other”中。

  • ValueError - 如果 mode 不是”bipartite”、”undirected”或”other”。

支持平台：

Ascend GPU

样例：

>>> from mindspore_gl.sampling import negative_sample
>>> positive = [[1,2],[2,3]]
>>> neg_len = 4
>>> neg = negative_sample(positive, 4, neg_len)
>>> print(neg)
[[0 3]
[0 2]
[1 3]
[0 1]]
mindspore_gl.sampling.random_walk_unbias_on_homo(homo_graph: mindspore_gl.graph.MindHomoGraph, seeds: numpy.ndarray, walk_length: int)[源代码]

同构图上的随机游走采样。

参数：

  • homo_graph (mindspore_gl.graph.MindHomoGraph) - 采样的源图。

  • seeds (numpy.ndarray) - 用于采样的随机种子。

  • walk_length (int) - 采样路径长度。

异常：

  • TypeError - 如果 walk_length 不是正整数。

  • TypeError - 如果 seeds 不是numpy.int32。

返回：

数组，示例节点 \((len(seeds), walk\_length)\)

支持平台：

Ascend GPU

样例：

>>> import numpy as np
>>> import networkx
>>> from scipy.sparse import csr_matrix
>>> from mindspore_gl.graph import MindHomoGraph, CsrAdj
>>> from mindspore_gl.sampling.randomwalks import random_walk_unbias_on_homo
>>> node_count = 10000
>>> edge_prob = 0.1
>>> graph = networkx.generators.random_graphs.fast_gnp_random_graph(node_count, edge_prob)
>>> edge_array = np.transpose(np.array(list(graph.edges)))
>>> row = edge_array[0]
>>> col = edge_array[1]
>>> data = np.zeros(row.shape)
>>> csr_mat = csr_matrix((data, (row, col)), shape=(node_count, node_count))
>>> generated_graph = MindHomoGraph()
>>> node_dict = {idx: idx for idx in range(node_count)}
>>> edge_count = col.shape[0]
>>> edge_ids = np.array(list(range(edge_count))).astype(np.int32)
>>> generated_graph.set_topo(CsrAdj(csr_mat.indptr.astype(np.int32), csr_mat.indices.astype(np.int32)),
... node_dict, edge_ids)
>>> nodes = np.arange(0, node_count)
>>> out = random_walk_unbias_on_homo(homo_graph=generated_graph, seeds=nodes[:5].astype(np.int32),
... walk_length=10)
>>> print(out)
# results will be random for suffle
[[   0 9493 8272 1251 3922 4180  211 1083 4198 9981 7669]
[   1 1585 1308 4703 1115 4989 9365 1098 1618 5987 8312]
[   2 2352 7214 5956 2184 1573 1352 7005 2325 6211 8667]
[   3 8723 5645 3691 4857 5501  113 4140 6666 2282 1248]
[   4 4354 9551 5224 3156 8693  346 8899 6046 6011 5310]]
mindspore_gl.sampling.sage_sampler_on_homo(homo_graph: mindspore_gl.graph.MindHomoGraph, seeds, neighbor_nums: List[int])[源代码]

MindHomoGraph上的GraphSage采样。

参数：

  • homo_graph (mindspore_gl.graph.MindHomoGraph) - 输入图。

  • seeds (numpy.ndarray) - 邻居采样的起始节点。

  • neighbor_nums (List) - 每跳的邻居数量。

返回：

  • layered_edges_{idx}(numpy.ndarray)，第idx跳时采样的重编号边数组。

  • layered_eids_{idx}(numpy.ndarray)，第idx跳时采样的边上点的重编号ID。

  • all_nodes，采样到的所有节点的ID。

  • seeds_idx，重编号的种子的ID。

异常：

  • TypeError - 如果 homo_graph 不是MindHomoGraph类。

  • TypeError - 如果 seeds 不是numpy.array。

  • TypeError - 如果 neighbor_nums 不是List。

支持平台：

Ascend GPU

样例：

>>> import networkx
>>> import numpy as np
>>> from scipy.sparse import csr_matrix
>>> from mindspore_gl.graph import MindHomoGraph, CsrAdj
>>> from mindspore_gl.sampling.neighbor import sage_sampler_on_homo
>>> node_count = 10
>>> edge_prob = 0.3
>>> graph = networkx.generators.random_graphs.fast_gnp_random_graph(node_count, edge_prob, seed=1)
>>> edge_array = np.transpose(np.array(list(graph.edges)))
>>> row = edge_array[0]
>>> col = edge_array[1]
>>> data = np.ones(row.shape)
>>> csr_mat = csr_matrix((data, (row, col)), shape=(node_count, node_count))
>>> generated_graph = MindHomoGraph()
>>> node_dict = {idx: idx for idx in range(node_count)}
>>> edge_count = col.shape[0]
>>> edge_ids = np.array(list(range(edge_count))).astype(np.int32)
>>> generated_graph.set_topo(CsrAdj(csr_mat.indptr.astype(np.int32), csr_mat.indices.astype(np.int32)),        ... node_dict, edge_ids)
>>> nodes = np.arange(0, node_count)
>>> res = sage_sampler_on_homo(homo_graph=generated_graph, seeds=nodes[:3].astype(np.int32),        ... neighbor_nums=[2, 2])
>>> print(res)
{'seeds_idx': array([0, 1, 2], dtype=int32), 'all_nodes': array([0, 1, 2, 4, 5, 6, 7, 8, 9], dtype=int32),
'layered_edges_0': array([[0, 0, 1, 1, 2], [1, 3, 4, 5, 4]], dtype=int32),
'layered_eids_0': array([[0, 0, 1, 1, 2], [1, 3, 4, 5, 4]], dtype=int32),
'layered_edges_1': array([[1, 1, 3, 3, 4, 5, 5], [4, 5, 7, 8, 6, 7, 8]], dtype=int32),
'layered_eids_1': array([[1, 1, 3, 3, 4, 5, 5], [4, 5, 7, 8, 6, 7, 8]], dtype=int32)}