算法

Ultipa 提供了丰富的算法支持,其中包括各种度中心算法,社区/聚类算法(如 Louvain,LPA等)。图嵌入算法 (如 随机游走,Node2Vec,LINE等) ,以及图遍历相关的(比如全图K邻算法等)。本章将会详细介绍如何执行一个算法,以及每个算法的具体参数与含义。由于Ultipa服务超高性能,使得算法的运行时间缩短了几十倍甚至上百倍,以至于将原先非常复杂算法变得具有实时性,所以在ultipa的算法包中,既包含实时计算的算法,如两点相似度计算,也包含近实时和异步任务的方式对全图、全量数据运行的算法,如Page Rank,LPA等。

  • 获取算法列表

    from ultipa import Connection,ULTIPA_REQUEST
    conn = Connection(host='host:port', username="root", password="root")
    ret = conn.listAlgo()
    print(ret.toJSON())
    
  • 算法执行

    算法执行的基础 [命令] 为 : algo()

10.1 中心度查询

点的度查询往往在科学计算,特征提取当中扮演着至关重要的角色。针对一个点的度计算,Ultipa会以实时(real-time)的方式执行,而针对全图所有点的度计算,将会以任务的方式进行。

针对单个点的度查询,算法的 [参数] 为:

名称 类型 规范 描述
node_id int >0.必填 需要计算的节点的id
edge_property_name str / 基于边属性的名称,可以为不填

针对全图的度查询,算法的 [参数] 为:

名称 类型 规范 描述
edge_property_name str / 基于边属性的名称,可以为不填

节点出度(Out Degree)

节点出度,即在Ultipa图系统中,计算某个点的出方向(右向)边的总数或者计算出方向边的某一位属性的总和。

from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret = conn.algo_out_degree(ALGO_REQUEST.Out_Degree(node_id=1))
print(ret.toJSON())

全图节点出度(Out Degree – All Nodes)

from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret = conn.algo_out_degree_all(ALGO_REQUEST.Out_Degree_All())
print(ret.toJSON())

节点入度(In Degree)

节点入度,即在Ultipa图系统中,计算某个点的入方向(左向)边的总数或者计算入方向边的某一位属性的总和。

from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret = conn.algo_in_degree(ALGO_REQUEST.In_Degree(node_id=1))
print(ret.toJSON())

全图节点入度(In Degree – All Nodes)

from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret = conn.algo_in_degree_all(ALGO_REQUEST.In_Degree_All())
print(ret.toJSON())

度中心度(Degree Centrality)

度中心度, 指定点入度和出度的和。

from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret = conn.algo_degree(ALGO_REQUEST.Degree(node_id=1))
print(ret.toJSON())

全图度中心度(Degree Centrality – All Nodes)

from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret = conn.algo_degree_all(ALGO_REQUEST.Degree_All())
print(ret.toJSON())

10.2 中心性计算

所有的中心性 相关算法的 [参数] 为:

名称 类型 规范 描述
node_id int > 0, 必填 需要计算的节点 id

接近中心性(Closeness Centrality)

接近中心性,即指定某个点,计算其它点到该点的最短路径的和的倒数。

from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret = conn.algo_closeness(ALGO_REQUEST.Closeness(node_id=1))
print(ret.toJSON())

点出接近中心性(Out Closeness Centrality)

点出接近中心性,与接近中心性原理类似,计算指定点,与其他点最短路径的和的倒数。但最短路径的计算中增加了对边的方向控制,只计算出方向(右向)的边。

from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret = conn.algo_out_closeness(ALGO_REQUEST.Out_Closeness(node_id=1))
print(ret.toJSON())

点入接近中心性(In Closeness Centrality)

点入接近中心性,计算指定点,与其他点最短路径的和的倒数。但最短路径的计算中,增加对边的方向控制,只计算入方向(左向)的边。

from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret = conn.algo_in_closeness(ALGO_REQUEST.In_Closeness(node_id=1))
print(ret.toJSON())

图中心度(Graph Centrality)

图中心度,即针对某个点,找出与其他点的最短路径长度的最大值, 并求该值的倒数。计算的结果能够表示该点是否位于图的最中心。

图中心度的结果适用于该点所在的连通分量当中。

from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret = conn.algo_graph_centrality(ALGO_REQUEST.Graph_Centrality(node_id=1))
print(ret.toJSON())

中介中心性(Betweenness Centrality)

按照Freeman(1977)的定义,中介中心性是指经过某节点n的所有最短路径的数量与该节点n对应的连通分量下所有其他节点间最短路径数量的比值:

由于需要计算全图经过该点n的最短路径数量,因此 中介中心性将会消耗较多计算资源,

from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret = conn.algo_betweenness_centrality(ALGO_REQUEST.Betweenness_Centrality())
print(ret.toJSON())

10.3 通用图算法

全图K邻查询

全图K邻查询,即对图中所有点进行K邻计算,统计所有点的第K步nodes的数量,并支持将统计结果回写到点属性当中。 例如,计算全图节点1 步邻居的数量,ultipa服务会自动为点创建一个名为#khop_1的属性,用于存放结果。

全图K邻 算法的 [参数] 为:

名称 类型 规范 描述
depth int >0,必填 k的值,也就是深度
from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret = conn.algo_k_hop(ALGO_REQUEST.Khop(depth=3))
print(ret.toJSON())

连通分量计算(Connected Component)

连通分量,即统计Ultipa图服务的数据中,能连通的极大图的个数,若为全连通图,那么对应的连通分量为1.

from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret = conn.algo_connected_component(ALGO_REQUEST.Connected_Component())
print(ret.toJSON())

三角形计算(Triangle Counting)

计算全图的三角形数量,在图论中,计算三角形的数量有着广泛的用途,比如社交网络发现,社区识别,紧密度分析,稳定性分析等。

from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret = conn.algo_triangle_counting(ALGO_REQUEST.Triangle_Counting())
print(ret.toJSON())

共同邻居数计算(Common Neighbours)

计算两个点的共同邻居数量:

Common Neighbours 算法的 [参数] 为:

名称 类型 规范 描述
node_id1 int >0,必填 /
node_id2 int >0.必填 /
from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret = conn.algo_common_neighbours(ALGO_REQUEST.Common_neighbours(node_id1=12,node_id2=21))
print(ret.toJSON())

子图拼接(subgraph)

计算若干点组成的子图

subgraph 算法的 [参数] 为:

名称 类型 规范 描述
node_ids List[int] 必填 需要组装的点(数组)
from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret = conn.algo_subgraph(ALGO_REQUEST.Subgraph(node_ids=[12,21,1,123,33445,544]))
print(ret.toJSON())

10.4 复杂图算法

图平均距离估算(hyperANF)

hyperANF, 全称:Approximating the Neighbourhood Function of Very Large Graphs on a Budget / 超大规模图最短邻居长度近似计算. 由意大利米兰大学信息科学系的Paolo Boldi, Marco Rosa ,Sebastiano Vigna于2011年提出。

hyperANF 算法的 [参数] 为:

名称 类型 规范 描述
loop_num int > 0 , 必填 迭代次数
register_num int > 0 , 必填 [4,30] default: 10
from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")ret = conn.algo_hyperANF(ALGO_REQUEST.HyperANF(loop_num=3,register_num=10))
print(ret.toJSON())

k最近邻(kNN)

邻近算法,或者说K最近邻(kNN,k-NearestNeighbor) ,通过计算得到和一个点最相似(例如cosine相似)的前k个点, 由这k个相似点得出该点的某一位属性或类别的值。

knn 算法的 [参数] 为:

名称 类型 规范 描述
node_id int 必填 需要计算的顶点id
node_property_names List[str] 必填 参与相似度计算的属性名列表
top int >0 使用多少相似节点进行计算
target_property_name str 必填 需要计算的目标属性名
from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret = conn.algo_knn(ALGO_REQUEST.Knn(node_id=12,node_property_names=['name','age'],
                                      top=50,target_property_name='name'))
print(ret.toJSON())

核心度(k-core)

计算某个子图中的最小点连接数,即所有顶点所连接的其他顶点数均大于等于该值。k-core可以帮助识别图中紧密连通的组的衡量标准。

名称 类型 规范 描述
k int 最大邻居数K
from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret = conn.algo_k_core(ALGO_REQUEST.Kcore(k=10))
print(ret.toJSON())

最小生成树(MST)

全称Minimum Spanning Tree。即原图中的极小连通子图,用最小的边的权重和,连通图中所有节点。

最小生成树 算法的 [参数] 为:

名称 类型 规范 描述
start_node_id int >0, 必填 开始的节点id
edge_property_name str / 依赖的边的属性名,不设置默认为1
from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret = conn.algo_mst(ALGO_REQUEST.Mst(start_node_id=12,edge_property_name='rank'))
print(ret.toJSON())

k均值(k-Means)

即对部分或者所有点,分成k类,依据对每个分类的质心的距离相近的原理标记。其中距离的评判标准分为两种,0)欧几里得距离;1)cosine相似度距离。

K均值 算法的 [参数] 为:

名称 类型 规范 描述
K均值的 配置 为: int >0,必填 分为k类
start_ids List[int] / 指定k个节点作为起始节点,若为空,自动取k个节点
node_property_names List[str] / 依据的属性名
distance_type int 0|1 0: 欧几里得距离
1:Cosine相似度距离
loop_num int > 0 , 必填 迭代次数,建议不要过大
from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret = conn.algo_k_means(ALGO_REQUEST.K_Means(start_ids=[12,21,2,23,1],
    k=2,node_property_names=['name','age'],distance_type=0,loop_num=3))
print(ret.toJSON())

局部聚集系数(Clustering Coefficient)

聚集系数,即计算一个系数来表示图的聚集程度。系数越大,聚集程度越高。

局部聚集系数,即对一个点进行聚集系数计算。

Clustering Coefficient 算法的 [参数] 为:

名称 类型 规范 描述
node_id int > 0, 必填 node ID
from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret = conn.algo_clustering_coefficient(ALGO_REQUEST.Clustering_Coefficient(node_id=12))
print(ret.toJSON())

10.5 社区识别与传播类算法

网页排名(Page Rank)

网页排名算法,最早主要用于通过网页之间的关系,来计算网页的重要性。从而为搜索结果提供排名依据。随着技术的发展与大量关联性数据的产生,page rank的使用被衍生到了众多领域,

因为Page Rank的计算涉及到全图数据,因此会以任务的方式执行。

Page Rank 算法的 [参数] 为::

名称 类型 规范 描述
loop_num int >0,必填 算法轮询的次数
damping float >0,<1,必填 阻尼系数
from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret = conn.algo_page_rank(ALGO_REQUEST.Page_Rank(loop_num=3,damping=0.5))
print(ret.toJSON())

西比尔算法(Sybil Rank)

Sybil 原指在线社交网络 OSN 中的虚假账号。由于社交网络的飞速发展,来自Sybil的攻击日益增多。通过 Sybil Rank算法,可以帮助社交平台或相关企业更高效的定位虚假账号(点)。

Sybil Rank 算法的 [参数] 为:

名称 类型 规范 描述
loop_num int > 0, 必填 算法轮询的次数
sybil_num int > 0, 必填 返回多少个最可疑的顶点
trust_seeds List[id] 必填 传入可信的点
total_trust int 必填 设置最多可信点数量
from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret = conn.algo_sybil_rank(ALGO_REQUEST.Sybil_Rank(loop_num=3,sybil_num=3,
                                      trust_seeds=[12,21],total_trust=10))
print(ret.toJSON())

标签传播算法(Label Propagation)

标签传播,顾名思义,是一套基于图中现有标签,通过传播来预测未标记的节点的标签。LPA算法拥有着广泛的应用场景,如:虚拟社区挖掘,多媒体信息分类等。

Label Propagation 算法的 [参数] 为:

名称 类型 规范 描述
loop_num int > 0, 必填 传播算法轮询次数
node_property_name string 必填 标签所在的属性名称
from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret = conn.algo_lpa(ALGO_REQUEST.Lpa(loop_num=5,node_property_name='name'))
print(ret.toJSON())

HANP (Hop Attenuation & Node Preference)

全称(Hop Attenuation & Node Preference),LPA算法的扩展,在迭代过程中加入了标签扩散的衰减因子和扩散节点的选择策略两个参数。

HANP 算法的 [参数] 为:

名称 类型 规范 描述
loop_num int > 0, 必填 传播算法轮询次数
edge_property_name string 必填, 属性类型:数字 传播所依赖的边属性
node_property_name str 必填 标签所在的属性名称
m float 必填 跟被传播点的邻居数有关系的一个参数正负都可以,正的:邻居多的点,负的:邻居少的点
delta float 必填 标签传播衰减的一个比例值越大衰减的越快0~+无穷
from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret = conn.algo_hanp(ALGO_REQUEST.Hanp(loop_num=3,edge_property_name='rank',
                                       node_property_name='name',m=1,delta=1.5))
print(ret.toJSON())

鲁汶社区识别算法 (Louvain)

Louvain算法是基于模块度的社区识别算法,通过相邻点的连通关系和权重值进行聚类,以最大化模块度为目标进行迭代计算。模块度越高,说明社区划分越明显; 模块越多,说明社区越多。

鲁汶算法会将最终每个点的所属社区id写回到点属性当中,且将最终的模块化值存于任务信息当中,除此之外,还将生成一个结果文件,用于记录每个社区的点的个数。

Louvain 算法的 [参数] 为:

名称 类型 规范 描述
phase1_loop_num int > 0, 必填 归纳社区轮询次数
min_modularity_increase float >0, 必填 触发停止的模块度变化的阈值
edge_property_name str / 基于的边属性
write_back bool 默认False 是否回写
visualization bool 默认 False 是否要可视化
from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret = conn.algo_louvain(ALGO_REQUEST.Louvain(phase1_loop_num=3,
                          min_modularity_increase=0.5,edge_property_name='rank'))
print(ret.toJSON())

鲁汶算法可视化

算法可视化将会在已有结果当中获取全部或者抽样进行数据展示,具体因算法而异。针对大数据集,louvain算法可视化将会通过抽样组装的方式进行。

louvain可视化 算法的 [参数] 为:

名称 类型 规范 描述
id int / 执行完算法的id,可通过showTask() 获取
algo_name str / 要可视化的算法名称
top int (0,10] 选取前N大社区
total int (0,10000] 设置抽样点的总数
from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret = conn.algo_dv(ALGO_REQUEST.Dv(algo_name='louvain',id=7,top=10))
# 通过showTask() 获取指定算法名的id
print(ret.toJSON())

10.6 相似度算法

杰卡德相似度(Jaccard Similarity)

杰卡德相似度,即给定两个集合A,B,A与B交集的大小与A与B并集相除的结果。结果系数越大,表示相似度越高。在图当中,通过比较点与该点的邻居的特性,组成不同集合,并做运算。

jassard 算法的 [参数] 为:

名称 类型 规范 描述
node_id1 int > 0, 必填 node1 的 ID
node_id2 int >0, node2 的ID
top int >0, 求node1 的最相似的N个点,当设置top时,node_id2将会失效
from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
# 计算两个点的相似度
ret = conn.algo_jaccard(ALGO_REQUEST.Jaccard(node_id1=12,node_id2=21))
print(ret.toJSON())
# 计算一个点的最相似的N个点
ret = conn.algo_jaccard(ALGO_REQUEST.Jaccard(node_id1=12,top=10))
print(ret.toJSON())

余弦相似度(Cosine Similarity)

余弦相似度,两个点的N个不同属性组成两个N维向量,计算这两个N维向量的夹角的余弦值来判断他们的相似度在Ultipa服务当中,结果在0到1之间,结果越大,表示相似性越高

Cosine_Similarity 算法的 [参数] 为:

名称 类型 规范 描述
node_id1 int > 0, 必填 node1 的 ID
node_id2 int >0, 必填 node2 的ID
node_property_names []string node的属性名, 逗号隔开, 至少两个属性,必填 参与计算余弦相似度的属性名称列表
  from ultipa import Connection,ALGO_REQUEST
  conn = Connection(host='host:port', username="root", password="root")
  ret = conn.algo_cosine_similarity(ALGO_REQUEST.Cosine_Similarity(
    node_id1=12,
    node_id2=21,
    node_property_names=['name','age']
  ))
  print(ret.toJSON())

10.7 图嵌入算法 (Graph Embedding)

嵌入算法来源于数学中的Embedding,目的是抽象高维的空间数据到低维的具象空间。图嵌入,即通过图的方式抽取高维数据形成低维可表示的因子,而不管高维还是低维,一般都为了表示某个点。

目前Ultipa服务支持了多种图嵌入算法,如随机游走,Node2Vec和Line算法。

随机游走(Random Walk) 图上任意点开始按照某种规则进行遍历,形成路径集合,该集合作为 embedding 的训练样本。ULTIPA 提供三种规则:

  • 完全随机游走
  • node2vec游走
  • 基于路径模板的游走
  • struc2vec 随机游走

完全随机游走(random_walk)

random_walk 算法的 [参数] 为: :

名称 类型 规范 描述
walk_num int >0, 必填 number of walker
walk_length walk_length >0, 必填 walking length
edge_property_name string / 沿着某一种边随机游走
from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret = conn.algo_random_walk(ALGO_REQUEST.Random_Walk(walk_num=2,
		walk_length=3,edge_property_name='rank'))
print(ret.toJSON())

Node2Vec 随机游走(random_walk_node2vec)

Node2Vec 随机游走的 配置 为:

Node2Vec 算法的 [参数] 为:

名称 类型 规范 描述
walk_num int >0, 必填 游走的次数
walk_length int >0, 必填 每次游走的距离/步数
p float >0, 必填 值越大,向回走的概率越小
q float >0, 必填 设置能向远处走的概率大于1:倾向同级走小于1:倾向向远处走
edge_property_name string 属性类型:数字number 游走当中的边的权重来源,若不设置,则都为1
from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret = conn.algo_random_walk_node2vec(ALGO_REQUEST.Random_Walk_Node2vec(
		walk_num=3,walk_length=2,p=0.1,q=0.1,edge_property_name='rank'))
print(ret.toJSON())

Struc2Vec 随机游走(random_walk_struc2vec)

random_walk_struc2vec 算法的 [参数] 为:

名称 类型 规范 描述
walk_num int >0, 必填 游走的次数
walk_length int >0, 必填 每次游走的距离/步数
k int 必填 层的数量(the number of layer), 建议小于等予全图平均最短
stay_probability float 必填 保留在当前层的概率(0,1)
from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret = conn.algo_random_walk_struc2vec(ALGO_REQUEST.Random_Walk_Stuc2vec(
		walk_num=3,walk_length=2,k=3,stay_probability=0.1))
print(ret.toJSON())

Node2Vec (node2vec)

Node2Vec是一种综合考虑DFS邻域和BFS邻域的图嵌入方法,通过结合了DFS和BFS的随机游走产生训练样本,使用Skip-gram和SGD的word2vec模型训练得到图中节点的embedding向量。 Node2Vec的图嵌入算法依赖于Node2Vec的随机游走算法。

Node2Vec 算法的 [参数] 为:

名称 类型 规范 描述
walk_num int >0, 必填 游走的次数
loop_num int > 0, 必填 传播算法轮询次数
walk_length int >0, 必填 每次游走的长度
p float >0, 必填 值越大,向回走的概率越小
q float 必填 设置能向远处走的概率大于1:倾向同级走小于1:倾向向远处走
context_size int > 0, 必填 window size
dimension int > 0, 必填 example: 100
learning_rate double > 0, < 1,必填 Recommend: 0.025
min_learning_rate double >0, <1,必填 example: learning_rate * 0.0001
sub_sample_alpha double / -1 as default,can be 0.001 in word2vec, the equation is (sqrt(x / 0.001) + 1) _ (0.001 / x)
resolution int 必填 Recommend: 10 or 100
neg_num int >0 number of words in negative sampling phrase (0, 10)
iter_num int >0 ,必填 loop number (0, 100)
min_frequency int >= 0 remove nodes that occur fewer than 'min_frequency
edge_property_name string 属性类型: number 游走当中的边的权重来源,若不设置,则都为1
from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret=conn.algo_node2vec(ALGO_REQUEST.Node2vec(walk_num=2,loop_num=2,
		walk_length=2,p=0.1,q=0.1,context_size=2,dimension=10,learning_rate=0.3
		min_learning_rate=0.3,sub_sample_alpha=0.001,resolution=2,
		neg_num=2,iter_num=2,min_frequency=0,edge_property_name='rank'))
print(ret.toJSON())

LINE算法(large information network embedding)

LINE也是一种图嵌入的训练模型,使用节点的BFS信息(一阶或二阶相似度)构造训练样本,使用和Node2Vec类似的方式训练得到节点的embedding向量。

LINE算法的 [参数] 为:

名称 类型 规范 描述
edge_property_name string 必填 edge property name
dimension int >0, 必填 dimension of the embedded vector , 10~n100 (e.g : 100)
resolution int >0, 必填 Recommend: 10 or 100
start_alpha double > 0, 必填 0.025 recommended
neg_num int >0 number of words in negative sampling phrase
total_sample int >0 ,必填 number of samples (0,10)
train_order int 1 or 2 1(first order proximity) 2(second order proximity)
from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret=conn.algo_line(ALGO_REQUEST.Line(edge_property_name='rank',
		dimension=2,resolution=3,start_alpha=0.0001,neg_num=1,
		total_sample=1,train_order=1))
print(ret.toJSON())

Struc2Vec算法(struc2vec)

Struc2Vec是从空间结构相似性的角度定义顶点相似度的。

struc2vec算法的 [参数] 为:

名称 类型 规范 描述
walk_num int >0, 必填 游走的次数
walk_length int >0, 必填 每次游走的步数
k int 必填 随机游走当中,分层数量
stay_probability float 必填 保持在当前层游走的概率
context_size int > 0, 必填 window size
dimension int > 0, 必填 example: 100
learning_rate double > 0, < 1,必填 Recommend: 0.025
min_learning_rate double >0, <1,必填 example: learning_rate * 0.0001
sub_sample_alpha double / -1 as default,can be 0.001 in word2vec, the equation is (sqrt(x / 0.001) + 1) * (0.001 / x)
resolution int 必填 Recommend: 10 or 100
neg_num int >0 number of words in negative sampling phrase
loop_num int >0 ,必填 loop number
min_frequency int >= 0 remove nodes that occur fewer than 'min_frequency'
from ultipa import Connection,ALGO_REQUEST
conn = Connection(host='host:port', username="root", password="root")
ret=conn.algo_struc2Vec(ALGO_REQUEST.Struc2Vec(walk_num=3,
		walk_length=2,k=2,stay_probability=0.2,context_size=0.5,
		dimension=10,learning_rate=0.025,min_learning_rate=0.001,
		sub_sample_alpha=0.001,resolution=10,neg_num=2,loop_num=3,
		min_frequency=3))
print(ret.toJSON())