手把手教你用 NebulaGraph AI 全家桶跑图算法

news2024/12/23 23:26:32

前段时间 NebulaGraph 3.5.0 发布，@whitewum 吴老师建议我把前段时间 NebulaGraph 社区里开启的新项目 ng_ai 公开给大家。

所以，就有了这个系列文章，本文是该系列的开篇之作。

ng_ai 是什么

ng_ai 的全名是：Nebulagraph AI Suite，顾名思义，它是在 NebulaGraph 之上跑算法的 Python 套件，希望能给 NebulaGraph 的用户一个自然、简洁的高级 API。简单来说，用很少的代码量就可以执行图上的算法相关的任务。

ng_ai 这个开源项目的目标是，快速迭代、公开讨论、持续演进，一句话概述便是：

Simplifying things in surprising ways.

这个 ng_ai 的专属 url：https://github.com/wey-gu/nebulagraph-ai 可以帮你了解更全面的它。

ng_ai 的特点

为了让 NebulaGraph 社区的小伙伴拥有顺滑的算法体验，ng_ai 有以下特点：

  • 与 NebulaGraph 紧密结合，方便从其中读、写图数据
  • 支持多引擎、后端，目前支持 Spark（NebulaGraph Algorithm）、NetworkX，之后会支持 DGL、PyG
  • 友好、符合直觉的 API 设计
  • 与 NebulaGraph 的 UDF 无缝结合，支持从 Query 中调用 ng_ai 任务
  • 友好的自定义算法接口，方便用户自己实现算法（尚未完成）
  • 一键试玩环境（基于 Docker Extensions）

你可以这么用 ng_ai

跑分布式 PageRank 算法

可以在一个大图上，基于 nebula-algorithm 分布式地跑 PageRank 算法，像是这样：

from ng_ai import NebulaReader

# scan 模式，通过 Spark 引擎读取数据
reader = NebulaReader(engine="spark")
reader.scan(edge="follow", props="degree")
df = reader.read()

# 运行 PageRank 算法
pr_result = df.algo.pagerank(reset_prob=0.15, max_iter=10)

写回算法结果到 NebulaGraph

假设我们要跑一个 Label Propagation 算法，然后把结果写回 NebulaGraph，我们可以这么做：

先确保结果中要写回图数据库的数据 Schema 已经创建好了，像是下面的示例，便是写到 label_propagation.cluster_id 字段里：

CREATE TAG IF NOT EXISTS label_propagation (
    cluster_id string NOT NULL
);

下面，我们来看下具体流程。执行算法：

df_result = df.algo.label_propagation()

再看一下结果的 Schema：

df_result.printSchema()

root
 |-- _id: string (nullable = false)
 |-- lpa: string (nullable = false)

参考下面的代码，把 lpa 的结果写回 NebulaGraph 中的 cluster_id 字段里（{"lpa": "cluster_id"}）：

from ng_ai import NebulaWriter
from ng_ai.config import NebulaGraphConfig

config = NebulaGraphConfig()
writer = NebulaWriter(
    data=df_result, sink="nebulagraph_vertex", config=config, engine="spark"
)

# 将 lpa 同 cluster_id 进行映射
properties = {"lpa": "cluster_id"}

writer.set_options(
    tag="label_propagation",
    vid_field="_id",
    properties=properties,
    batch_size=256,
    write_mode="insert",
)
# 将数据写回到 NebulaGraph
writer.write()

最后，验证一下：

USE basketballplayer;
MATCH (v:label_propagation)
RETURN id(v), v.label_propagation.cluster_id LIMIT 3;

结果：

+-------------+--------------------------------+
| id(v)       | v.label_propagation.cluster_id |
+-------------+--------------------------------+
| "player103" | "player101"                    |
| "player113" | "player129"                    |
| "player121" | "player129"                    |
+-------------+--------------------------------+

更详细的例子参考：ng_ai/examples

通过 nGQL 调用算法

自 NebulaGraph v3.5.0 开始，用户可从 nGQL 中调用自己实现的函数。而 ng_ai 也用这个能力来实现了一个自己的 ng_ai 函数，让它从 nGQL 中调用 ng_ai 的算法，例如：

-- 准备将要写入数据的 Schema
USE basketballplayer;
CREATE TAG IF NOT EXISTS pagerank(pagerank string);
:sleep 20;
-- 回调 ng_ai()
RETURN ng_ai("pagerank", ["follow"], ["degree"], "spark", {space: "basketballplayer", max_iter: 10}, {write_mode: "insert"})

更详细的例子参考：ng_ai/examples

单机运行算法

在单机、本地的环境，ng_ai 支持基于 NetworkX 运行算法。

举个例子，读取图为 ng_ai graph 对象：

from ng_ai import NebulaReader
from ng_ai.config import NebulaGraphConfig

# query 模式，通过 NebulaGraph 或是 NetworkX 引擎读取数据
config_dict = {
    "graphd_hosts": "graphd:9669",
    "user": "root",
    "password": "nebula",
    "space": "basketballplayer",
}
config = NebulaGraphConfig(**config_dict)
reader = NebulaReader(engine="nebula", config=config)
reader.query(edges=["follow", "serve"], props=[["degree"], []])
g = reader.read()

查看、画图：

g.show(10)
g.draw()

运行算法：

pr_result = g.algo.pagerank(reset_prob=0.15, max_iter=10)

写回 NebulaGraph：

from ng_ai import NebulaWriter

writer = NebulaWriter(
    data=pr_result,
    sink="nebulagraph_vertex",
    config=config,
    engine="nebula",
)

# 待写入的属性
properties = ["pagerank"]

writer.set_options(
    tag="pagerank",
    properties=properties,
    batch_size=256,
    write_mode="insert",
)
# 将数据写回到 NebulaGraph
writer.write()

其他算法：

# 获取所有算法
g.algo.get_all_algo()

# 获取相关算法的帮助信息
help(g.algo.node2vec)

# 调用算法
g.algo.node2vec()

更详细的例子参考：ng_ai/examples

可视化图算法结果

这里演示一个 NetworkX 引擎情况下，计算 Louvain、PageRank 并可视化的例子：

先执行两个图算法：

pr_result = g.algo.pagerank(reset_prob=0.15, max_iter=10)
louvain_result = g.algo.louvain()

再手写一个画图好看的函数：

from matplotlib.colors import ListedColormap


def draw_graph_louvain_pr(G, pr_result, louvain_result, colors=["#1984c5", "#22a7f0", "#63bff0", "#a7d5ed", "#e2e2e2", "#e1a692", "#de6e56", "#e14b31", "#c23728"]):
    # 设定节点的位置
    pos = nx.spring_layout(G)

    # 新建一个图形并设置坐标轴
    fig, ax = plt.subplots(figsize=(35, 15))
    ax.set_xlim(-1, 1)
    ax.set_ylim(-1, 1)

    # 从颜色列表中创建一个 colormap
    cmap = ListedColormap(colors)

    # 将图中的节点和边进行绘图
    node_colors = [louvain_result[node] for node in G.nodes()]
    node_sizes = [70000 * pr_result[node] for node in G.nodes()]
    nx.draw_networkx_nodes(G, pos=pos, ax=ax, node_color=node_colors, node_size=node_sizes, cmap=cmap, vmin=0, vmax=max(louvain_result.values()))

    nx.draw_networkx_edges(G, pos=pos, ax=ax, edge_color='gray', width=1, connectionstyle='arc3, rad=0.2', arrowstyle='-|>', arrows=True)

    # 提取边数据中的 label 数据作为字典
    edge_labels = nx.get_edge_attributes(G, 'label')

    # 在图中加入边的 label 数据
    for edge, label in edge_labels.items():
        ax.text((pos[edge[0]][0] + pos[edge[1]][0])/2,
                (pos[edge[0]][1] + pos[edge[1]][1])/2,
                label, fontsize=12, color='black', ha='center', va='center')

    # 在图中加入点的 label 数据
    node_labels = {n: G.nodes[n]['label'] if 'label' in G.nodes[n] else n for n in G.nodes()}
    nx.draw_networkx_labels(G, pos=pos, ax=ax, labels=node_labels, font_size=12, font_color='black')

    # 为同社区数据添加相同颜色
    sm = plt.cm.ScalarMappable(cmap=cmap, norm=plt.Normalize(vmin=0, vmax=max(louvain_result.values())))
    sm.set_array([])
    cbar = plt.colorbar(sm, ax=ax, ticks=range(max(louvain_result.values()) + 1), shrink=0.5)
    cbar.ax.set_yticklabels([f'Community {i}' for i in range(max(louvain_result.values()) + 1)])

    # 数据展示
    plt.show()

draw_graph_louvain_pr(G, pr_result=pr_result, louvain_result=louvain_result)

效果如下所示：

更详细的例子参考：ng_ai/examples

更方便的 Notebook 操作 NebulaGraph

结合 NebulaGraph 的 Jupyter Notebook 插件: https://github.com/wey-gu/ipython-ngql，我们还可以更便捷地操作 NebulaGraph：

可通过 ng_ai 的 extras 在 Jupyter Notbook 中安装插件：

%pip install ng_ai[jupyter]
%load_ext ngql

当然，也可以单独安装插件：

%pip install ipython-ngql
%load_ext ngql

安装完成后，就可以在 Notebook 里直接使用 %ngql 命令来执行 nGQL 语句：

%ngql --address 127.0.0.1 --port 9669 --user root --password nebula
%ngql USE basketballplayer;
%ngql MATCH (v:player{name:"Tim Duncan"})-->(v2:player) RETURN v2.player.name AS Name;

注，多行的 Query 用两个百分号就好了 %%ngql

最后，我们还能在 Jupyter Notebook 里直接可视化渲染结果！只需要 %ng_draw 就可以啦！

%ngql match p=(:player)-[]->() return p LIMIT 5
%ng_draw

效果如下：

未来工作

现在 ng_ai 还在开发中，我们还有很多工作要做：

  • 完善 Reader 模式，现在 NebulaGraph / NetworkX 的读取数据只支持 Query-Mode，还需要支持 Scan-Mode
  • 实现基于 dgl（GNN）的链路预测、节点分类等算法，例如：
model = g.algo.gnn_link_prediction()
result = model.train()
# query src, dst to be predicted

model.predict(src_vertex, dst_vertices)
  • UDA，自定义算法
  • 快速部署工具

ng_ai 完全 build in public，欢迎社区的大家们来参与，一起来完善 ng_ai，让 NebulaGraph 上的 AI 算法更加简单、易用！

试玩 ng_ai

我们已经准备好了一键部署的 NebulaGraph + NebulaGraph Studio + ng_ai in Jupyter 的环境，只需要大家从 Docker Desktop 的 Extension（扩展）中搜索 NebulaGraph，就可以试玩了。

  • 安装 NebulaGraph Docker 插件

在 Docker Desktop 的插件市场搜索 NebulaGraph，点击安装：

  • 安装 ng_ai Playground

进入 NebulaGraph 插件，点击 Install NX Mode，安装 ng_ai 的 NetworkX Playground，通常要等几分钟等待安装完成。

  • 进入 NetworkX Playground

点击 Jupyter NB NetworkX，进入 NetworkX Playground。

ng_ai 的架构

ng_ai 的架构如下，它的核心模块有：

  • Reader：负责从 NebulaGraph 读取数据
  • Writer：负责将数据写入 NebulaGraph
  • Engine：负责适配不同运行时，例如 Spark、DGL、NetowrkX 等
  • Algo：算法模块，例如 PageRank、Louvain、GNN_Link_Predict 等

此外，为了支持 nGQL 中的调用，还有两个模块：

  • ng_ai-udf：负责将 UDF 注册到 NebulaGraph，接受 ng_ai 的 Query 调用，访问 ng_ai API
  • ng_ai-api：ng_ai 的 API 服务，接受 UDF 的调用，访问 ng_ai 核心模块
          ┌───────────────────────────────────────────────────┐
          │   Spark Cluster                                   │
          │    .─────.    .─────.    .─────.    .─────.       │
          │   ;       :  ;       :  ;       :  ;       :      │
       ┌─▶│   :       ;  :       ;  :       ;  :       ;      │
       │  │    ╲     ╱    ╲     ╱    ╲     ╱    ╲     ╱       │
       │  │     `───'      `───'      `───'      `───'        │
  Algo Spark                                                  │
    Engine└───────────────────────────────────────────────────┘
       │  ┌────────────────────────────────────────────────────┬──────────┐
       └──┤                                                    │          │
          │   NebulaGraph AI Suite(ngai)                       │ ngai-api │◀─┐
          │                                                    │          │  │
          │                                                    └──────────┤  │
          │     ┌────────┐    ┌──────┐    ┌────────┐   ┌─────┐            │  │
          │     │ Reader │    │ Algo │    │ Writer │   │ GNN │            │  │
 ┌───────▶│     └────────┘    └──────┘    └────────┘   └─────┘            │  │
 │        │          │            │            │          │               │  │
 │        │          ├────────────┴───┬────────┴─────┐    └──────┐        │  │
 │        │          ▼                ▼              ▼           ▼        │  │
 │        │   ┌─────────────┐ ┌──────────────┐ ┌──────────┐ ┌──────────┐  │  │
 │     ┌──┤   │ SparkEngine │ │ NebulaEngine │ │ NetworkX │ │ DGLEngine│  │  │
 │     │  │   └─────────────┘ └──────────────┘ └──────────┘ └──────────┘  │  │
 │     │  └──────────┬────────────────────────────────────────────────────┘  │
 │     │             │        Spark                                          │
 │     │             └────────Reader ────────────┐                           │
 │  Spark                   Query Mode           │                           │
 │  Reader                                       │                           │
 │Scan Mode                                      ▼                      ┌─────────┐
 │     │  ┌───────────────────────────────────────────────────┬─────────┤ ngai-udf│◀─────────────┐
 │     │  │                                                   │         └─────────┤              │
 │     │  │  NebulaGraph Graph Engine         Nebula-GraphD   │   ngai-GraphD     │              │
 │     │  ├──────────────────────────────┬────────────────────┼───────────────────┘              │
 │     │  │                              │                    │                                  │
 │     │  │  NebulaGraph Storage Engine  │                    │                                  │
 │     │  │                              │                    │                                  │
 │     └─▶│  Nebula-StorageD             │    Nebula-Metad    │                                  │
 │        │                              │                    │                                  │
 │        └──────────────────────────────┴────────────────────┘                                  │
 │                                                                                               │
 │    ┌───────────────────────────────────────────────────────────────────────────────────────┐  │
 │    │ RETURN ng_ai("pagerank", ["follow"], ["degree"], "spark", {space:"basketballplayer"}) │──┘
 │    └───────────────────────────────────────────────────────────────────────────────────────┘
 │  ┌─────────────────────────────────────────────────────────────┐
 │  │ from ng_ai import NebulaReader                              │
 │  │                                                             │
 │  │ # read data with spark engine, scan mode                    │
 │  │ reader = NebulaReader(engine="spark")                       │
 │  │ reader.scan(edge="follow", props="degree")                  │
 └──│ df = reader.read()                                          │
    │                                                             │
    │ # run pagerank algorithm                                    │
    │ pr_result = df.algo.pagerank(reset_prob=0.15, max_iter=10)  │
    │                                                             │
    └─────────────────────────────────────────────────────────────┘

谢谢你读完本文 (///▽///)

欢迎前往 GitHub 来阅读 NebulaGraph 源码，或是尝试用它解决你的业务问题 yo~ GitHub 地址：https://github.com/vesoft-inc/nebula

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/745403.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

安装RabbitMQ 详细步骤

安装RabbitMQ 详细步骤

我这里是在Linux系统里面安装的按照步骤即可 1. 安装Socat🍉 在线安装依赖环境： yum install gcc yum install socat yum install openssl yum install openssl-devel2. 安装Erlang🍉 去官网下载一下安装包，将安装包拉到Linux系…
阅读更多...
苹果APP安装包ipa如何安装在手机上

苹果APP安装包ipa如何安装在手机上

苹果APP的安装比安卓复杂且困难，很多人不知道如何将ipa文件安装到手机上。以下是几种苹果APP安装在iOS设备的方式，供大家参考。 一、上架App Store 这是最正规的方式。虽然审核过程复杂、时间较长，且审核条件较为苛刻，但借助第三…
阅读更多...
【UE C++】蓝图调用C++函数

【UE C++】蓝图调用C++函数

目录 一、蓝图调用其继承的C类的函数 二、蓝图调用全局C函数 一、蓝图调用其继承的C类的函数 首先新建一个C类 父类选择“Actor” 这里命名为“MyActorFromC”，然后点击创建类，等待编译完成。 在头文件中申明函数 UFUNCTION(BlueprintCallable, Categ…
阅读更多...
list分段截取方法

list分段截取方法

对list 分段截取方法是一个常见的操作，通常用于对list数据批量操作，常见的场景有返回分页展示数据，对大数据进行分批次插入数据库等 package com.hmdp.dto;import org.apache.commons.collections4.ListUtils; import org.springframework.u…
阅读更多...
Golang学习——string和slice切片

Golang学习——string和slice切片

Golang学习——string和slice切片 string整数存储字符存储Unicode存储变长编码规则字符串类型变量的结构字符串变量的修改方式 slice通过make的方式定义变量new底层数组slice扩容规则1.预估扩容后的容量newCap2.newCap个元素需多大内存3.匹配到合适的内存规格练习 string 整数…
阅读更多...
如何进行高效的日程管理？

如何进行高效的日程管理？

在日程安排逐渐增多的现代职场中，如果想要高效完成工作事项，就必须做好每天的日常管理。但是有不少上班族表示自己在做日程管理时往往感到力不从心，很难做到真正有效的管理自己的日程安排，那么问如何进行高效的日程管理呢&#xf…
阅读更多...
利用Python数据挖掘技术深入理解股票回撤的本质

利用Python数据挖掘技术深入理解股票回撤的本质

股票回撤是投资者关注的一个重要指标，也是进行风险评估和投资决策的必要依据。通过利用Python数据挖掘技术深入理解股票回撤的本质，可以更加准确地评估风险和制定投资策略。 一、什么是股票回撤 股票回撤是指股票价格在上涨过程中出现暂时的下跌&#…
阅读更多...
2023开放式蓝牙耳机推荐，开放式耳机如何选购？十五款开放式耳机一文看到底！

2023开放式蓝牙耳机推荐，开放式耳机如何选购？十五款开放式耳机一文看到底！

最近发现网上很多小伙伴在挑选开放式蓝牙耳机，也看到很多开放式耳机的评测文章，五花八门，各式各样，导致很多小伙伴想挑选一款好用的开放式耳机，却又怕踩雷！ 那么问题来了！怎样选择一款合适的开…
阅读更多...
代码随想录二刷 day48 |动态规划之 198打家劫舍 213打家劫舍II 337打家劫舍III

代码随想录二刷 day48 |动态规划之 198打家劫舍 213打家劫舍II 337打家劫舍III

day48 198.打家劫舍1.确定dp数组（dp table）以及下标的含义2.确定递推公式3.dp数组如何初始化4.确定遍历顺序5.举例推导dp数组 213.打家劫舍II情况一：考虑不包含首尾元素情况二：考虑包含首元素，不包含尾元素情况三&…
阅读更多...
在培训班里学技术，真的有用吗？

在培训班里学技术，真的有用吗？

在培训班里学技术，真的有用吗？ 😇博主简介：我是一名正在攻读研究生学位的人工智能专业学生，我可以为计算机、人工智能相关本科生和研究生提供排忧解惑的服务。如果您有任何问题或困惑，欢迎随时来交流哦&…
阅读更多...
打印机从0到入门

打印机从0到入门

一.连接 1.USB连接方式 2.网络打印服务器连接方式 使用打印服务器可以将不能联网的打印机设置为同一网段下的主机均可使用，有的打印服务器也可跨网段连接。 二.共享 不同终端处于同个网络下，主机网络通信通过WIFI连接（打印机连接的主机通…
阅读更多...
2023最新 Navicat 16.2.3 安装和试用教程详解

2023最新 Navicat 16.2.3 安装和试用教程详解

🌷🍁 博主 libin9iOak带您 Go to New World.✨🍁 🦄 个人主页——libin9iOak的博客🎐 🐳 《面试题大全》 文章图文并茂🦕生动形象🦖简单易学！欢迎大家来踩踩~&#x1f33…
阅读更多...
四个按键控制led的四种变化（按键控制led）（附源码）

四个按键控制led的四种变化（按键控制led）（附源码）

文章目录 一、实验任务二、系统框图三、代码实现四、引脚分配五、总结 一、实验任务 使用开发板上的四个按键控制四个LED灯。按下不同的按键时，四个LED灯显示不同效果。本实验是在EP4CE6F17C8开发板上实现，仿真请用modelsim Altera 二、系统框图 三、代…
阅读更多...
23 分页控件

23 分页控件

文章目录 界面设置初始化主对话框子页面初始化 页面1枚举窗口页面2枚举进程全部代码 界面设置 ui 设置 >创建CTablCtrl > 创建页控件（子窗口），style设置成为chlid 添加类 页面中加入listCtrl 控件 添加变量 分别添加初始化函数 初始化…
阅读更多...
3ds Max 建模基础教程：创建棕榈植物

3ds Max 建模基础教程：创建棕榈植物

推荐： NSDT场景编辑器助你快速搭建可二次开发的3D应用场景 嘿伙计们，在本教程中，我们将学习如何使用其花盆创建棕榈植物，首先我们将对花盆进行建模，然后设置叶子和纹理，我从谷歌搜索中找到了纹理&#xff0…
阅读更多...
常用的k8s管理命令

常用的k8s管理命令

Kubernetes 是一个由主节点和工作节点组成的容器编排工具。它只允许通过作为控制平面核心组件的 API 服务器进行通信。API 服务器公开了一个 HTTP REST API，允许内部组件（如用户和集群）和外部组件之间的通信。 你可以将 API 服务器视为 Kuber…
阅读更多...
RestClient操作索引库

RestClient操作索引库

一、初始化RestClient 分为三步&#xff1a; 1&#xff09;引入es的RestHighLevelClient依赖&#xff1a; <dependency><groupId>org.elasticsearch.client</groupId><artifactId>elasticsearch-rest-high-level-client</artifactId> </dep…
阅读更多...
字节面试：连接一个不存在的 IP 地址，会发生什么？

字节面试：连接一个不存在的 IP 地址，会发生什么？

分享两个字节面试题&#xff0c;都是基于场景问的网络问题。 Q1&#xff1a;客户端连接一个不存在的 IP 地址&#xff0c;会发生什么&#xff1f; Q2&#xff1a;客户端连接一个存在的 IP 地址但是端口不存在&#xff0c;会发生什么&#xff1f; PS&#xff1a;这里的「连接…
阅读更多...
leetcode:2395. 和相等的子数组(python3解法)

leetcode:2395. 和相等的子数组(python3解法)

难度&#xff1a;简单 给你一个下标从 0 开始的整数数组 nums &#xff0c;判断是否存在 两个 长度为 2 的子数组且它们的 和 相等。注意&#xff0c;这两个子数组起始位置的下标必须 不相同 。 如果这样的子数组存在&#xff0c;请返回 true&#xff0c;否则返回 false 。 子数…
阅读更多...
快消品行业企业如何选择适合自己的订单管理系统源码

快消品行业企业如何选择适合自己的订单管理系统源码

快消品行业企业在选择适合自己的订单管理系统源码时&#xff0c;需要考虑以下五个方面&#xff1a; 首先&#xff0c;企业需要考虑订单管理系统的功能是否能够满足自身的需求。订单管理系统应该具备订单录入、订单查询、订单处理、订单跟踪、进销存管理、临期提醒等基本功能&am…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023