分析应用¶

应用资产¶

class graphscope.framework.app.AppAssets(algo=None, context=None, gar=None, cmake_extra_options=None)[源代码]¶

一个类，表示DAG中的一个应用资产节点，用于保存gar资源的字节数据。

资产包括算法名称和gar（用于用户自定义算法），上下文类型（可选'tensor'、'vertex_data'、'vertex_property'、'labeled_vertex_data'、'dynamic_vertex_data'、'labeled_vertex_property'之一），及其类型（可选cpp_pie、cpp_pregel、cython_pie、cython_pregel之一），

该类的实例可以传递给初始化 graphscope.framework.app.AppDAGNode

__init__(algo=None, context=None, gar=None, cmake_extra_options=None)[源代码]¶

初始化算法的资产。

Parameters:

algo (str) – 表示资源内部的特定算法。
context (str) – 保存计算结果的上下文类型。
无。 (如果参数为None，将从gar获取。默认为) –
gar (bytes 或 BytesIO, 可选) – 编码应用程序源代码的字节数据。默认为None。

property algo¶

算法名称，例如sssp、pagerank。

Returns:: 该资产的算法名称。
Return type:: 字符串

property context_type¶

上下文类型，例如顶点属性、带标签的顶点数据。

Returns:: 应用上下文的类型。
Return type:: 字符串

property gar¶

Gar资源。

Returns:: 该资产的gar资源。
Return type:: 字节

is_compatible(graph)[源代码]¶

判断该算法能否在此类图上运行。

Parameters:

graph (GraphDAGNode) – 一个图实例。

Raises:

InvalidArgumentError –
- 应用与图不兼容
ScannerError –
- Yaml文件格式不正确。

property signature¶

根据算法名称（及gar资源）生成应用资产的签名。

用于唯一标识一个应用资产。

Returns:: 该资产的签名
Return type:: 字符串

property type¶

算法类型，可选值为 cpp_pie、cpp_pregel、cython_pie、java_pie 或 cython_pregel。

Returns:: 该资产的算法类型。
Return type:: 字符串

Java应用¶

class graphscope.analytical.app.JavaApp(full_jar_path: str, java_app_class: str)[源代码]¶

一个类，表示DAG中持有jar文件的Java应用断言节点。

它包含了运行Java应用程序所需的必要资源，包括Java类路径、由jar和配置yaml组成的gar文件，以及指定的Java类。在创建JavaApp时，graphscope会尝试加载指定的Java类，并解析应用程序的基类以及上下文类的基类。此操作要求在创建graphscope会话的客户端机器上安装Java运行时环境。

要运行您的应用程序，请为JavaApp提供一个属性图或投影图以及您的查询参数。

__call__(graph: 图, *args, **kwargs)[源代码]¶: 实例化一个App并对其执行查询。

__init__(full_jar_path: str, java_app_class: str)[源代码]¶

使用您的jar文件的完整路径和应用程序类的完全限定名称来初始化JavaApp。

Parameters:

full_jar_path (str) – jar文件所在的路径。
java_app_class (str) – 您的应用程序类的完全限定名称。

is_compatible(graph)[源代码]¶

判断该算法能否在此类图上运行。

Parameters:

graph (GraphDAGNode) – 一个图实例。

Raises:

InvalidArgumentError –
- 应用程序与graph不兼容
ScannerError –
- Yaml文件格式不正确。

signature()[源代码]¶

根据算法名称（及gar资源）生成应用资产的签名。

用于唯一标识一个应用资产。

Returns:: 该资产的签名
Return type:: 字符串

App 对象¶

class graphscope.framework.app.AppDAGNode(graph, app_assets: AppAssets)[源代码]¶

一个类，表示DAG中的一个应用节点。

在GraphScope中，应用节点绑定了一个具体的图节点，查询将在该节点上执行。

class graphscope.framework.app.App(app_node, key)[源代码]¶

一个可以在图上运行并生成结果的应用程序。

分析引擎在实例化应用实例时会构建应用的动态库。如果后续应用的签名与之前任一应用匹配，该动态库将被重复使用。

__del__()[源代码]¶: 卸载应用。包括引擎端和Python端。将键设置为None。

__init__(app_node, key)[源代码]¶

property key¶: 应用程序的唯一标识符。

property signature¶: 签名由该应用的所有关键组件计算得出。

功能¶

graphscope.framework.app.load_app([gar, ...])

从gar加载一个应用。

内置应用¶

graphscope.attribute_assortativity_coefficient(graph, attribute)[源代码]¶

计算节点属性的同配性。

同配性衡量图中连接在给定属性上的相似性。

Parameters:

graph (graphscope.Graph) – 一个简单的图。
attribute (str) – 节点属性键。

Returns:

针对给定属性的图同配性

Return type:

r (浮点数)

备注

该公式计算参考文献[1]_中的方程(2)：(trace(M)-sum(M^2))/(1-sum(M^2))，其中M是指定属性的联合概率分布(混合矩阵)。

参考文献

[1] M. E. J. Newman, 网络中的混合模式, Physical Review E, 67 026126, 2003

示例:

>>> import graphscope
>>> from graphscope.dataset import load_modern_graph
>>> sess = graphscope.session(cluster_type="hosts", mode="eager")
>>> g = load_modern_graph(sess)
>>> g.schema
>>> c = graphscope.attribute_assortativity_coefficient(g, attribute="name")
>>> sess.close()

graphscope.numeric_assortativity_coefficient(graph, attribute)[源代码]¶

计算数值节点属性的同配性。

同配性衡量图中连接在给定数值属性上的相似程度。

Parameters:

graph (graphscope.Graph) – 一个简单的图。
attribute (str) – 节点属性键。

Returns:

针对给定属性的图同配性

Return type:

r (浮点数)

示例

>>> import graphscope
>>> from graphscope.dataset import load_modern_graph
>>> sess = graphscope.session(cluster_type="hosts", mode="eager")
>>> g = load_modern_graph(sess)
>>> g.schema
>>> c = graphscope.numeric_assortativity_coefficient(g, attribute="name")
>>> sess.close()

备注

这计算了参考文献[1]_中的公式(21)，用于指定属性的混合矩阵。

参考文献

graphscope.average_degree_connectivity(graph, source='in+out', target='in+out', weight=None)[源代码]¶

计算图的平均度连通性。

平均度连接性是指度数为k的节点的平均最近邻度数。对于加权图，可以使用[1]_中定义的加权平均邻居度数来计算类似度量，对于节点i，表示为

\[k_{nn,i}^{w} =\]

rac{1}{s_i} sum_{j in N(i)} w_{ij} k_j

其中 s_i 表示节点 i 的加权度， w_{ij} 是连接 i 和 j 的边的权重，而 N(i) 是节点 i 的邻居集合。

graph : (graphscope.Graph): 一个简单的图。

source“in”|”out”|”in+out” (default:”in+out”)
仅适用于有向图。使用“入度”或“出度”作为源节点。

target“in”|”out”|”in+out” (default:”in+out”
仅适用于有向图。针对目标节点使用"入度"或"出度"。

weightstring or None, optional (default=None)
用于作为权重的数值所对应的边属性。如果为None，则每条边的权重默认为1。

ddict
一个以度数k为键、平均连通性为值的字典。

ValueError
如果source或target不是'in'、'out'或'in+out'其中之一。
>>> import graphscope
>>> from graphscope.dataset import load_modern_graph
>>> sess = graphscope.session(cluster_type="hosts", mode="eager")
>>> g = load_modern_graph(sess)
>>> g.schema
>>> c = graphscope.average_degree_connectivity(g, weight="weight")
>>> sess.close()
[1]
A. Barrat, M. Barthélemy, R. Pastor-Satorras 和 A. Vespignani， "复杂加权网络的结构"。《美国国家科学院院刊》101 (11): 3747–3752 (2004).

graphscope.average_shortest_path_length(graph, weight=None)[源代码]¶

计算平均最短路径长度。

平均最短路径长度为

\[a =\sum_{s,t \in V} \frac{d(s, t)}{n(n-1)}\]

其中V表示图G中的节点集合，d(s, t)是从s到t的最短路径，而n是图G中的节点数量。

Parameters:

graph ((graphscope.Graph): 一个简单的图。) –
weight ((str, optional): 边权重对应的边数据键。) – 注意多标签下的属性应保持一致的索引。默认为 None。

Returns:

r – 平均最短路径长度。

Return type:

浮点数

示例

>>> import graphscope
>>> from graphscope.dataset import load_modern_graph
>>> sess = graphscope.session(cluster_type="hosts", mode="eager")
>>> g = load_modern_graph(sess)
>>> g.schema
>>> c = graphscope.average_shortest_path_length(g, weight="weight")
>>> sess.close()

graphscope.bfs(graph, src=0)[源代码]¶

从源节点开始在投影简单图上进行广度优先搜索。

Parameters:

graph (graphscope.Graph) – 一个简单的图。
src (可选) – 广度优先搜索的源顶点。该类型应与graph的ID类型保持一致，即根据graph的oid_type是int64_t还是string，对应为int或str类型。默认为0。

Returns:

一个包含每个顶点到源点距离的上下文，将在即时模式下进行评估。

Return type:

graphscope.framework.context.VertexDataContextDAGNode

示例:

>>> import graphscope
>>> from graphscope.dataset import load_p2p_network
>>> sess = graphscope.session(cluster_type="hosts", mode="eager")
>>> g = load_p2p_network(sess)
>>> # project to a simple graph (if needed)
>>> pg = g.project(vertices={"host": ["id"]}, edges={"connect": ["dist"]})
>>> c = graphscope.bfs(pg, src=6)
>>> sess.close()

graphscope.avg_clustering(graph, degree_threshold=1000000000)[源代码]¶

计算有向图的平均聚类系数。

Parameters:

graph (graphscope.Graph) – 一个简单的图。
degree_threshold (int, optional) - 过滤度数大于阈值的超级顶点。默认为1e9。

Returns:

float: 平均聚类系数。

Return type:

示例:

>>> import graphscope
>>> from graphscope.dataset import load_p2p_network
>>> sess = graphscope.session(cluster_type="hosts", mode="eager")
>>> g = load_p2p_network(sess)
>>> # project to a simple graph
>>> pg = g.project(vertices={"host": ["id"]}, edges={"connect": ["dist"]})
>>> c = graphscope.avg_clustering(pg)
>>> print(c.to_numpy("r", axis=0)[0])
>>> sess.close()

graphscope.clustering(graph, degree_threshold=1000000000)[源代码]¶

图中节点的局部聚类系数是指该节点的邻居节点中彼此相邻的节点对所占的比例。

Parameters:

graph (graphscope.Graph) – 一个简单的图。
degree_threshold (int, optional) – 过滤度数大于阈值的超级顶点。默认为1e9。

Returns:

一个为每个顶点分配了计算聚类值的上下文，将在即时模式下进行评估。

Return type:

graphscope.framework.context.VertexDataContextDAGNode

示例:

>>> import graphscope
>>> from graphscope.dataset import load_p2p_network
>>> sess = graphscope.session(cluster_type="hosts", mode="eager")
>>> g = load_p2p_network(sess)
>>> # project to a simple graph (if needed)
>>> pg = g.project(vertices={"host": ["id"]}, edges={"connect": ["dist"]})
>>> c = graphscope.clustering(pg)
>>> sess.close()

graphscope.degree_assortativity_coefficient(graph, x='out', y='in', weight=None)[源代码]¶

计算图的度同配性。

同配性衡量图中节点度数之间连接的相似性。

:param graph (graphscope.Graph): :type graph (graphscope.Graph): 一个简单图。 :param x: 源节点的度数类型（仅适用于有向图）。 :type x: string ('in','out') :param y: 目标节点的度数类型（仅适用于有向图）。 :type y: string ('in','out') :param weighted: 加权图或非加权图 :type weighted: bool (True, False)

Returns:

r (float) - 基于度的图同配性系数
示例
.. code:: python – >>> import graphscope >>> from graphscope.dataset import load_modern_graph >>> sess = graphscope.session(cluster_type="hosts", mode="eager") >>> g = load_modern_graph(sess) >>> g.schema >>> c = graphscope.degree_assortativity_coefficient(g, weight="weight") >>> sess.close()

备注

这计算了参考文献[1]_中的公式(21)，其中e是度的联合概率分布（混合矩阵）。如果G是有向图，那么矩阵e就是用户指定的源节点和目标节点度类型的联合概率。

参考文献

graphscope.degree_centrality(graph, centrality_type='both')[源代码]¶

度中心性值通过除以简单图中的最大可能度数n-1进行归一化，其中n是图G中的节点数量。

Parameters:

graph (Graph) – 一个简单的图。
centrality_type (str, optional) – 可选值为in/out/both。默认为"both"。

Returns:

一个上下文，其中每个顶点都被分配了计算得出的度中心性，以即时模式进行评估。

Return type:

graphscope.framework.context.VertexDataContextDAGNode

示例:

>>> import graphscope
>>> from graphscope.dataset import load_p2p_network
>>> sess = graphscope.session(cluster_type="hosts", mode="eager")
>>> g = load_p2p_network(sess)
>>> # project to a simple graph (if needed)
>>> pg = g.project(vertices={"host": ["id"]}, edges={"connect": ["dist"]})
>>> c = graphscope.degree_centrality(pg, centrality_type="both")
>>> sess.close()

graphscope.eigenvector_centrality(graph, tolerance=1e-06, max_round=100, weight=None)[源代码]¶

Compute the eigenvector centrality for the graph. See more about eigenvector centrality here: https://networkx.org/documentation/networkx-1.10/reference/generated/networkx.algorithms.centrality.eigenvector_centrality.html

Parameters:

graph (graphscope.Graph) – 一个简单的图。
tolerance (float, optional) – 默认为1e-06。
max_round (int, optional) – 默认为100。
weight (str, optional) – 边权重对应的边数据键值。注意多标签下的属性应保持一致的索引。默认为None。

Returns:

一个上下文，其中每个顶点都被分配了一个gv-centrality值，以即时模式进行评估。

Return type:

graphscope.framework.context.VertexDataContextDAGNode

示例:

>>> import graphscope
>>> from graphscope.dataset import load_p2p_network
>>> sess = graphscope.session(cluster_type="hosts", mode="eager")
>>> g = load_p2p_network(sess)
>>> # project to a simple graph (if needed)
>>> pg = g.project(vertices={"host": ["id"]}, edges={"connect": ["dist"]})
>>> c = graphscope.eigenvector_centrality(pg, tolerance=1e-06, max_round=10)
>>> sess.close()

graphscope.hits(graph, tolerance=0.01, max_round=100, normalized=True)[源代码]¶

在graph上计算HITS。

超链接诱导主题搜索（HITS，也称为枢纽与权威）是一种用于评估网页的链接分析算法。更多信息请参阅： https://en.wikipedia.org/wiki/HITS_algorithm

Parameters:

graph (graphscope.Graph) – 一个简单的图。
tolerance (float, optional) – 默认为0.01。
max_round (int, optional) – 默认为100。
normalized (bool, optional) – 是否将结果归一化到0-1范围内。默认为True。

Returns:

一个上下文，其中每个顶点都被分配了HITS值，以即时模式进行评估。

Return type:

graphscope.framework.context.VertexPropertyContextDAGNode

示例:

>>> import graphscope
>>> from graphscope.dataset import load_p2p_network
>>> sess = graphscope.session(cluster_type="hosts", mode="eager")
>>> g = load_p2p_network(sess)
>>> # project to a simple graph (if needed)
>>> pg = g.project(vertices={"host": ["id"]}, edges={"connect": ["dist"]})
>>> c = graphscope.hits(pg, tolerance=0.01, max_round=10, normalized=True)
>>> sess.close()

graphscope.is_simple_path(graph, nodes)[源代码]¶

当且仅当nodes在G中构成一条简单路径时返回True。

图中的简单路径是指一个非空的节点序列，其中没有节点在序列中出现超过一次，并且序列中每对相邻节点在图中也是相邻的。

:param graph (graphscope.Graph): :type graph (graphscope.Graph): 一个简单的图。 :param nodes: 图中的节点列表，包含G中的一个或多个节点。 :type nodes: list

Returns:: 给定的节点列表是否代表G中的一条简单路径。
Return type:: 布尔值

备注

空节点列表不是路径，但单节点列表是路径。以下是原因说明。

该函数作用于节点路径。也可以考虑使用边路径。节点路径和边路径之间存在双射关系。

路径长度是指路径中的边数，因此一个长度为n的节点列表对应着长度为n-1的路径。因此最小的边路径将是零条边的列表，即空路径。这对应于一个包含单个节点的列表。

要在节点路径和边路径之间进行转换，可以使用如下代码：

>>> from networkx.utils import pairwise
>>> nodes = [0, 1, 2, 3]
>>> edges = list(pairwise(nodes))
>>> edges
[(0, 1), (1, 2), (2, 3)]
>>> nodes = [edges[0][0]] + [v for u, v in edges]
>>> nodes
[0, 1, 2, 3]

示例

>>> import graphscope
>>> from graphscope.dataset import load_p2p_network
>>> sess = graphscope.session(cluster_type="hosts", mode="eager")
>>> g = load_p2p_network(sess)
>>> # project to a simple graph (if needed)
>>> pg = g.project(vertices={"host": ["id"]}, edges={"connect": ["dist"]})
>>> c = graphscope.is_simple_path(pg, [2, 3, 8])
>>> print(c)
>>> sess.close()

graphscope.k_core(graph, k: int)[源代码]¶

图的K-核是指在移除所有度数小于k的顶点后，剩余的连通分量。

Parameters:

graph (graphscope.Graph) – 一个简单的图。
k (int) – 核心的阶数。

Returns:

为每个顶点分配布尔值的上下文：: 如果顶点满足k-core条件则为1，否则为0。

以即时模式评估。

Return type:

graphscope.framework.context.VertexDataContextDAGNode

示例:

>>> import graphscope
>>> from graphscope.dataset import load_p2p_network
>>> sess = graphscope.session(cluster_type="hosts", mode="eager")
>>> g = load_p2p_network(sess)
>>> # project to a simple graph (if needed)
>>> pg = g.project(vertices={"host": ["id"]}, edges={"connect": ["dist"]})
>>> c = graphscope.k_core(pg, k=3)
>>> sess.close()

graphscope.k_shell(graph, k: int)[源代码]¶

k壳层是由核心数为k的节点诱导的子图。也就是说，k核中不属于(k+1)核的节点构成了k壳层。

Parameters:

graph (graphscope.Graph) – 一个简单的图。
k (int) – k_shell的阶数。

Returns:

每个顶点分配一个布尔值的上下文：: 如果顶点满足k-shell则为1，否则为0。

在即时执行模式下评估。

Return type:

graphscope.framework.context.VertexDataContextDAGNode

示例:

>>> import graphscope
>>> from graphscope.dataset import load_p2p_network
>>> sess = graphscope.session(cluster_type="hosts", mode="eager")
>>> g = load_p2p_network(sess)
>>> # project to a simple graph (if needed)
>>> pg = g.project(vertices={"host": ["id"]}, edges={"connect": ["dist"]})
>>> c = graphscope.k_shell(pg, k=3)
>>> sess.close()

graphscope.katz_centrality(graph, alpha=0.1, beta=1.0, tolerance=1e-06, max_round=100, normalized=True, degree_threshold=1000000000.0)[源代码]¶

计算Katz中心性。

See more details for Katz centrality here: https://networkx.org/documentation/stable/reference/algorithms/generated/networkx.algorithms.centrality.katz_centrality_numpy.html

Parameters:

graph (graphscope.Graph) – 一个简单的图。
alpha (float, optional) – 衰减因子。默认为0.1。
beta (float, 可选参数) – 赋予直接邻域的权重。默认为1.0。
tolerance (float, optional) – 误差容限。默认为1e-06。
max_round (int, optional) – 最大轮数。默认为100。
normalized (bool, optional) – 是否对结果值进行归一化处理。默认为True。
degree_threshold (int, optional) – 过滤度数大于阈值的超级顶点。默认为1e9。

Returns:

一个上下文，其中每个顶点都被分配了计算得到的katz_centrality值，以即时模式进行评估。

Return type:

graphscope.framework.context.VertexDataContextDAGNode

示例:

>>> import graphscope
>>> from graphscope.dataset import load_p2p_network
>>> sess = graphscope.session(cluster_type="hosts", mode="eager")
>>> g = load_p2p_network(sess)
>>> # project to a simple graph (if needed)
>>> pg = g.project(vertices={"host": ["id"]}, edges={"connect": ["dist"]})
>>> c = graphscope.katz_centrality(pg)
>>> sess.close()

graphscope.louvain(graph, min_progress=1000, progress_tries=1)[源代码]¶

通过louvain算法计算图的最佳分区。

Parameters:

graph (graphscope.Graph) – 一个简单的无向图。
min_progress – 被视为进展所需的最小增量X，其中X表示在特定轮次中改变社区的节点数量。增量X即为当前轮次相比前一轮次改变社区的节点数量差异。
progress_tries – 在退出当前层级并压缩图之前，未达到min_progress设置的次数

Returns:

一个上下文，其中每个顶点都被分配了其所属社区的ID，以即时模式进行评估。

Return type:

graphscope.framework.context.VertexDataContextDAGNode

参考文献

[1] Blondel, V.D. 等. 大型网络中社区的快速展开. J. Stat. Mech 10008, 1-12(2008).

[2] https://github.com/Sotera/distributed-graph-analytics

[3] https://sotera.github.io/distributed-graph-analytics/louvain/

备注

louvain 目前仅支持无向图。如果输入图是有向图，louvain 会抛出 InvalidArgumentError 错误。

示例:

>>> import graphscope
>>> from graphscope.dataset import load_p2p_network
>>> sess = graphscope.session(cluster_type="hosts", mode="eager")
>>> g = load_p2p_network(sess, directed=False)
>>> # project to a simple graph (if needed)
>>> pg = g.project(vertices={"host": ["id"]}, edges={"connect": ["dist"]})
>>> c = graphscope.louvain(pg, min_progress=1000, progress_tries=1)
>>> sess.close()

graphscope.cdlp(graph, max_round=10)¶

使用标签传播评估社区检测。

Parameters:

graph (graphscope.Graph) – 一个简单的图。
max_round (int, optional) – 最大轮数。默认为10。

Returns:

一个为每个顶点分配了社区ID的上下文，将在即时模式下进行评估。

Return type:

graphscope.framework.context.VertexDataContextDAGNode

示例:

>>> import graphscope
>>> from graphscope.dataset import load_p2p_network
>>> sess = graphscope.session(cluster_type="hosts", mode="eager")
>>> g = load_p2p_network(sess)
>>> # project to a simple graph (if needed)
>>> pg = g.project(vertices={"host": ["id"]}, edges={"connect": ["dist"]})
>>> c = graphscope.lpa(pg, max_round=10)
>>> sess.close()

graphscope.lpa(graph, max_round=10)[源代码]¶

使用标签传播评估社区检测。

Parameters:

graph (graphscope.Graph) – 一个简单的图。
max_round (int, optional) – 最大轮数。默认为10。

Returns:

一个为每个顶点分配了社区ID的上下文，将在即时模式下进行评估。

Return type:

graphscope.framework.context.VertexDataContextDAGNode

示例:

>>> import graphscope
>>> from graphscope.dataset import load_p2p_network
>>> sess = graphscope.session(cluster_type="hosts", mode="eager")
>>> g = load_p2p_network(sess)
>>> # project to a simple graph (if needed)
>>> pg = g.project(vertices={"host": ["id"]}, edges={"connect": ["dist"]})
>>> c = graphscope.lpa(pg, max_round=10)
>>> sess.close()

graphscope.lpa_u2i(graph, max_round=10)[源代码]¶

在属性图上评估（多）标签传播。

Parameters:

graph (graphscope.Graph) – 一个属性图。
max_round (int, optional) – 最大轮数。默认为10。

Returns:

一个包含每个顶点的上下文，跟随一系列传播的标签，在即时模式下进行评估。

Return type:

graphscope.framework.context.LabeledVertexPropertyContextDAGNode

示例:

import graphscope as gs
g = gs.g()
# Load some data
r = gs.lpa(g)
s.close()

graphscope.pagerank(graph, delta=0.85, max_round=10)[源代码]¶

在图上评估PageRank算法。

Parameters:

graph (graphscope.Graph) – 一个简单的图。
delta (float, optional) – 阻尼因子。默认为0.85。
max_round (int, optional) – 最大轮数。默认为10。

Returns:

一个上下文，其中每个顶点都被分配了pagerank值，以即时模式进行评估。

Return type:

graphscope.framework.context.VertexDataContextDAGNode

示例:

>>> import graphscope
>>> from graphscope.dataset import load_p2p_network
>>> sess = graphscope.session(cluster_type="hosts", mode="eager")
>>> g = load_p2p_network(sess)
>>> # project to a simple graph (if needed)
>>> pg = g.project(vertices={"host": ["id"]}, edges={"connect": ["dist"]})
>>> c = graphscope.pagerank(pg, delta=0.85, max_round=10)
>>> sess.close()

graphscope.pagerank_nx(graph, alpha=0.85, max_iter=100, tol=1e-06)[源代码]¶

使用与NetworkX库中完全相同的算法在图上评估pagerank。

Parameters:

graph (graphscope.Graph) – 一个简单的图。
alpha (float, optional) – 阻尼系数。默认为0.85。
max_iter (int, optional) – 最大迭代次数。默认为100。
tol (float, optional) – 幂迭代求解器中用于检查收敛性的误差容限。

Returns:

一个上下文，其中每个顶点都被分配了pagerank值，以即时模式进行评估。

Return type:

graphscope.framework.context.VertexDataContextDAGNode

示例:

>>> import graphscope
>>> from graphscope.dataset import load_p2p_network
>>> sess = graphscope.session(cluster_type="hosts", mode="eager")
>>> g = load_p2p_network(sess)
>>> # project to a simple graph (if needed)
>>> pg = g.project(vertices={"host": ["id"]}, edges={"connect": ["dist"]})
>>> c = graphscope.pagerank_nx(pg,  alpha=0.85, max_iter=10, tol=1e-06)
>>> sess.close()

graphscope.sssp(graph, src=0, weight=None)[源代码]¶

在图上计算单源最短路径长度。

请注意，sssp算法要求边具有数值属性。

Parameters:

graph (graphscope.Graph) – 一个简单的图。
src (可选) – 源顶点。其类型应与graph的ID类型保持一致，即根据graph的oid_type是int64_t还是string，对应为int或str类型。默认为0。
weight (str, optional) – 边权重对应的边数据键值。注意多标签下的属性应保持一致的索引。默认为None。

Returns:

一个上下文，其中每个顶点都被分配了从src出发的最短距离，以即时模式进行评估。

Return type:

graphscope.framework.context.VertexDataContextDAGNode

示例:

>>> import graphscope
>>> from graphscope.dataset import load_p2p_network
>>> sess = graphscope.session(cluster_type="hosts", mode="eager")
>>> g = load_p2p_network(sess)
>>> # project to a simple graph (if needed)
>>> pg = g.project(vertices={"host": ["id"]}, edges={"connect": ["dist"]})
>>> c = graphscope.sssp(pg, src=6)
>>> sess.close()

graphscope.triangles(graph)[源代码]¶

评估图G的三角形计数。

Parameters:: graph (graphscope.Graph) – 一个简单的图。
Returns:: 一个上下文环境，其中每个顶点都被分配了三角形计数结果，并以即时模式进行评估。
Return type:: graphscope.framework.context.VertexDataContextDAGNode

示例:

>>> import graphscope
>>> from graphscope.dataset import load_p2p_network
>>> sess = graphscope.session(cluster_type="hosts", mode="eager")
>>> g = load_p2p_network(sess)
>>> # project to a simple graph (if needed)
>>> pg = g.project(vertices={"host": ["id"]}, edges={"connect": ["dist"]})
>>> c = graphscope.triangles(pg)
>>> sess.close()

graphscope.voterank(graph, num_of_nodes=0)[源代码]¶

在图上评估VoteRank算法。

Parameters:

graph (graphscope.Graph) – 一个简单的图。
num_of_nodes (unsigned long int, optional) – 要提取的排名节点数量。默认为所有节点。

Returns:

一个上下文，其中每个顶点都被分配了voterank值，以即时模式进行评估。

Return type:

graphscope.framework.context.VertexDataContextDAGNode

示例:

>>> import graphscope
>>> from graphscope.dataset import load_p2p_network
>>> sess = graphscope.session(cluster_type="hosts", mode="eager")
>>> g = load_p2p_network(sess)
>>> # project to a simple graph (if needed)
>>> pg = g.project(vertices={"host": ["id"]}, edges={"connect": ["dist"]})
>>> c = graphscope.voterank(pg, num_of_nodes=10)
>>> sess.close()

graphscope.wcc(graph)[源代码]¶

在graph上评估弱连通分量。这是WCC的优化版本。请注意，此功能无法针对具有多个标签的属性图进行编译。

Parameters:: graph (graphscope.Graph) – 一个简单的图。
Returns:: 一个上下文，其中每个顶点都被分配了组件ID，以即时模式进行评估。
Return type:: graphscope.framework.context.VertexDataContextDAGNode

示例:

>>> import graphscope
>>> from graphscope.dataset import load_p2p_network
>>> sess = graphscope.session(cluster_type="hosts", mode="eager")
>>> g = load_p2p_network(sess)
>>> # project to a simple graph (if needed)
>>> pg = g.project(vertices={"host": ["id"]}, edges={"connect": ["dist"]})
>>> c = graphscope.wcc(pg)
>>> sess.close()