---

本文为学习产物，学习链接（如有侵权，请告知删除）：
人工智能【图神经网络实战】教程，让你一天就学会深入浅出图神经网络GNN，从入门到精通！

一、图神经网络应用领域

1.1 芯片设计

芯片的设计比较耗费人力和物力，如果可以通过AI算法自动设计芯片，则可以大大提高芯片制造的效率，降低芯片制造的成本

1.2 场景分析与问题推理

例如剧本杀中的推理，警匪片中嫌疑人的图推理等

1.3 推荐系统

例如，刷抖音，经常看英雄联盟的游戏视频，那么说明你对游戏比较感兴趣，系统会根据网络图结构推荐更多和英雄联盟相关的内容给你

1.4 欺诈检测与风控相关

贷款软件，读取用户的通讯录信息和app使用情况，从而测评用户的还款能力，然后决定用户的借款额度

1.5 知识图谱

智能客服

1.6 道路交通的流量预测

预测道路上每条边的流量

1.7 自动驾驶（无人机等场景）

1.8 化学，医疗等场景

利用AI对化学结构进行分析，预测

1.9 物理模型相关

根据分子结构进行相关分析

---

二、图神经网络基本知识

2.1 图基本模块定义

V：点，每个点都有自己的特征向量（特征举例：邻居点数量、一阶二阶相似度）
E：边，每个边都有自己的特征向量（特征举例：边的权重值、边的定义）
U：整个图，每个图都有自己的特征向量（特征举例：节点数量、图直径）

2.2 图神经网络要做的事情

• 为每个节点整合特征向量，根据其对节点做分类或者回归
• 为每条边整合特征向量，根据其对边做分类或者回归
• 为每张图整合特征向量，根据其对图做分类或者回归
  

2.3 邻接矩阵的定义

2.3.1 图数据的邻接矩阵

2.3.2 文本数据的邻接矩阵

2.4 GNN中的常见任务

传统神经网络（CNN、RNN、DNN）要求输入格式是固定的（如24×24、128×128等）。

但在实际场景中（例如道路交通），不同城市的道路数量和节点数量都不同，即输入数据格式不固定。对此，传统神经网络不能很好地解决，但是GNN可以用来解决此类问题。

对于输入数据格式不固定的情况，GNN的常见任务有以下几种：

2.4.1 Graph级别任务

基于整个图，做分类和回归。
例如，给定一个分子结构图，判断它里面存在几个环 或者 判断该分子结构属于哪一类

2.4.2 Node与Edge级别任务

预测这个点是教练还是学员，即预测点
预测两个点之间的关系（是打架关系还是观看关系），即预测边

2.5 消息传递计算方法

2.5.1 优化邻接矩阵

之前学过，邻接矩阵的大小为N*N，当节点很多的时候，邻接矩阵的大小也会特别大

为了解决这个问题，我们一般采取只保存source数组和target数组的方式

source数组即起点（起源点）数组，target数组即终点（目标点）数组

这两个数组的维度是一样的

对应位置的source和target值就可以代表一条可连接的有向边，对于没有连接关系的边则不需要保存其信息，这样就可以大大减少数据规模

2.5.2 点的特征重构

汇总 = 自身的信息 + 所有邻居点的信息

所有邻居点信息的表达有几种：

• 求解Sum
• 求平均Mean
• 求最大Max
• 求最小Min
  

2.6 多层GNN的作用

层数越多，GNN的“感受野”越大，每个点考虑其他点的信息越多，考虑越全面

GNN输出特征的用处

---

三、GCN详解

3.1 GCN基本模型概述

3.1.1 卷积 vs 图卷积

卷积：卷积核平移计算

图卷积：自身信息+所有邻居信息

3.1.2 图中常见任务

3.1.3 如果获取特征

3.1.4 半监督学习

GCN属于半监督学习（不需要每个节点都有标签都可以进行训练）

计算Loss时，只需要考虑有标签的节点即可。

为了减少有标签节点的Loss，其周围的点也会做相应的调整，这也是图结构的特点，因此GNN和GCN中，不需要所有节点都有标签也可以进行训练（当然至少需要一个节点有标签）

3.2 图卷积的基本计算方法

3.2.1 GCN基本思想

• 对每个节点计算特征
• 然后合成每个节点的特征
• 将合成的特征传入全连接网络进行分类
  

3.2.2 GCN层数

图卷积也可以做多层，但是一般不做太深层，一般只做2-3层
（类似于一种说法，你只需要认识6个人就可以认识全世界）


实验表明：GCN中，深层的网络结构往往不会带来更好的效果。
直观解释：我表哥认识的朋友的朋友的朋友的朋友认识市长，不代表我和市长关系就很好。

层数越多，特征表达就越发散

一般2-5层即可

3.2.3 图中基本组成

3.2.4 特征计算方法

3.3 邻接矩阵的变换

单位矩阵相当于给每个节点加了一条自连接的边

但是现在存在一个问题：一个节点的度越大，其做矩阵乘法后的值就越大（累加次数变多了），这种情况是不好的（相当于一个人认识的人越多，其的特征值就越大，这样不好）

为了解决这个问题，我们需要对度矩阵求倒数，相当于平均的感觉，对度数大的节点加以限制


上面的左乘相当于对行做了归一化操作，那么列也需要做归一化操作

但是又有问题了，行和列都做了归一化，那不是会存在2次归一化的情况吗（行列重叠处）

所以我们需要在度矩阵倒数那加一个0.5次方来抵消这个2次归一化的影响

3.4 GCN变换原理解读

如下图所示，假设绿色框中的人是个富人，红色框中的人是个穷人，他们只是小时候认识，穷人只认识富人，而富人认识很多人。

如果只对行做归一化，由于穷人只认识富人，所以其度为1，则其在进行特征重构的时候很大一部分信息会来自于富人，这样的模型大概率会认为穷人和富人是同一种人。显然，这是不合理的

所以，我们需要同时对行和列都进行归一化，这样不仅只考虑富人对穷人的关系，还考虑了穷人对富人的关系。

简单来说，对行做归一化考虑到了，富人对穷人来说很重要；对列作归一化，考虑到了穷人对富人可能没那么重要（因为富人的度很大，穷人的度很小，富人很可能不记得穷人了），这样相对更加合理。

3.5 GCN传播公式

softmax是作多分类常用的激活函数

---

四、PyTorch Geometric 库的基本使用

4.1 PyTorch Geometric 的安装

注意： 千万不要直接pip install 去安装这个库！！！

进入这个GitHub网址： https://github.com/pyg-team/pytorch_geometric

进入页面后往下滑，找到如下图所示的字样，点击here

选择你电脑中已经安装的torch版本（一定要和你已经安装的torch版本一致）

怎么查看torch版本？

在Pycharm中，点击底部栏的Terminal，输入pip show torch，即可查看torch版本

选择完正确的torch版本后，会进入下面的界面，一共有4个不同的.whl文件，每一种选一个符合你的版本下载即可

例如：torch_cluster-1.5.9-cp36-cp36m-win_amd64.whl 指的是python为3.6的windows版本

我的电脑是windows的，python版本为3.8.12，所以我下载的四个包如下图所示：

下载好之后，直接pip install 你的.whl文件地址

下面是我安装时候的命令（仅供参考）:

pip install C:\Users\WSKH\Desktop\torch_cluster-1.5.9-cp38-cp38-win_amd64.whl

pip install ‪C:\Users\WSKH\Desktop\torch_scatter-2.0.6-cp38-cp38-win_amd64.whl

pip install C:\Users\WSKH\Desktop\torch_sparse-0.6.9-cp38-cp38-win_amd64.whl

pip install ‪C:\Users\WSKH\Desktop\torch_spline_conv-1.2.1-cp38-cp38-win_amd64.whl

最后，一定要等上面四步完成之后，再执行下面的操作

pip install torch-geometric

4.2 数据集与邻接矩阵格式

4.2.1 数据集介绍

Hello World 级别的数据集，34个节点

4.2.2 数据探索

from torch_geometric.datasets import KarateClubdataset = KarateClub()
print(f'Dataset:{dataset}:')
print('=' * 30)
print(f'Number of graphs:{len(dataset)}')
print(f'Number of features:{dataset.num_features}')
print(f'Number of classes:{dataset.num_classes}')print('=' * 30)
data = dataset[0]
# train_mask = [True,False,...] ：代表第1个点是有标签的，第2个点是没标签的，方便后面LOSS的计算
print(data)  # Data(x=[节点数, 特征数], edge_index=[2, 边的条数], y=[节点数], train_mask=[节点数])

输出：

Dataset:KarateClub():
==============================
Number of graphs:1
Number of features:34
Number of classes:4
==============================
Data(x=[34, 34], edge_index=[2, 156], y=[34], train_mask=[34])

4.2.3 使用networkx进行可视化展示

import os
from torch_geometric.datasets import KarateClub
from torch_geometric.utils import to_networkx
import networkx as nx
import matplotlib.pyplot as plt# 画图函数
def visualize_graph(G, color):plt.figure(figsize=(7, 7))plt.xticks([])plt.yticks([])nx.draw_networkx(G, pos=nx.spring_layout(G, seed=42), with_labels=False,node_color=color, cmap="Set2")plt.show()# 画点函数
def visualize_embedding(h, color, epoch=None, loss=None):plt.figure(figsize=(7, 7))plt.xticks([])plt.yticks([])h = h.detach().cpu().numpy()plt.scatter(h[:, 0], h[:, 1], s=140, c=color, cmap="Set2")if epoch is not None and loss is not None:plt.xlabel(f'Epoch:{epoch},Loss:{loss.item():.4f}', fontsize=16)plt.show()if __name__ == '__main__':# 不加这个可能会报错os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'dataset = KarateClub()print(f'Dataset:{dataset}:')print('=' * 30)print(f'Number of graphs:{len(dataset)}')print(f'Number of features:{dataset.num_features}')print(f'Number of classes:{dataset.num_classes}')print('=' * 30)data = dataset[0]# train_mask = [True,False,...] ：代表第1个点是有标签的，第2个点是没标签的，方便后面LOSS的计算print(data)  # Data(x=[节点数, 特征数], edge_index=[2, 边的条数], y=[节点数], train_mask=[节点数])G = to_networkx(data, to_undirected=True)visualize_graph(G, color=data.y)

可视化结果：

4.2.4 GCN模型搭建

import torch
from torch.nn import Linear
from torch_geometric.nn import GCNConvclass GCN(torch.nn.Module):def __init__(self, num_features, num_classes):super(GCN, self).__init__()torch.manual_seed(520)self.num_features = num_featuresself.num_classes = num_classesself.conv1 = GCNConv(self.num_features, 4)  # 只定义子输入特证和输出特证即可self.conv2 = GCNConv(4, 4)self.conv3 = GCNConv(4, 2)self.classifier = Linear(2, self.num_classes)def forward(self, x, edge_index):# 3层GCNh = self.convl(x, edge_index)  # 给入特征与邻接矩阵（注意格式，上面那种）h = h.tanh()h = self.conv2(h.edge_index)h = h.tanh()h = self.conv3(h, edge_index)h = h.tanh()# 分类层out = self.classifier(h)return out, h

4.2.5 使用搭建好的GCN模型

import os
import timefrom torch_geometric.datasets import KarateClub
import networkx as nx
import matplotlib.pyplot as plt
import torch
from torch.nn import Linear
from torch_geometric.nn import GCNConv# 画图函数
def visualize_graph(G, color):plt.figure(figsize=(7, 7))plt.xticks([])plt.yticks([])nx.draw_networkx(G, pos=nx.spring_layout(G, seed=42), with_labels=False,node_color=color, cmap="Set2")plt.show()# 画点函数
def visualize_embedding(h, color, epoch=None, loss=None):plt.figure(figsize=(7, 7))plt.xticks([])plt.yticks([])h = h.detach().cpu().numpy()plt.scatter(h[:, 0], h[:, 1], s=140, c=color, cmap="Set2")if epoch is not None and loss is not None:plt.xlabel(f'Epoch:{epoch},Loss:{loss.item():.4f}', fontsize=16)plt.show()class GCN(torch.nn.Module):def __init__(self, num_features, num_classes):super(GCN, self).__init__()torch.manual_seed(520)self.num_features = num_featuresself.num_classes = num_classesself.conv1 = GCNConv(self.num_features, 4)  # 只定义子输入特证和输出特证即可self.conv2 = GCNConv(4, 4)self.conv3 = GCNConv(4, 2)self.classifier = Linear(2, self.num_classes)def forward(self, x, edge_index):# 3层GCNh = self.conv1(x, edge_index)  # 给入特征与邻接矩阵（注意格式，上面那种）h = h.tanh()h = self.conv2(h, edge_index)h = h.tanh()h = self.conv3(h, edge_index)h = h.tanh()# 分类层out = self.classifier(h)return out, h# 训练函数
def train(data):optimizer.zero_grad()out, h = model(data.x, data.edge_index)loss = criterion(out[data.train_mask], data.y[data.train_mask])loss.backward()optimizer.step()return loss, hif __name__ == '__main__':# 不加这个可能会报错os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'# 数据集准备dataset = KarateClub()data = dataset[0]# 声明GCN模型model = GCN(dataset.num_features, dataset.num_classes)# 损失函数 交叉熵损失criterion = torch.nn.CrossEntropyLoss()# 优化器 Adamoptimizer = torch.optim.Adam(model.parameters(), lr=0.01)# 训练for epoch in range(401):loss, h = train(data)if epoch % 100 == 0:visualize_embedding(h, color=data.y, epoch=epoch, loss=loss)time.sleep(0.3)

输出图片：

---

五、文献引用数据集分类案例实战（基于点的任务）

5.1 数据集介绍

5.2 数据探索

from torch_geometric.datasets import Planetoid
from torch_geometric.transforms import NormalizeFeaturesif __name__ == "__main__":# 数据准备dataset = Planetoid(root='../data/Planetoid', name='Cora', transform=NormalizeFeatures())  # transform预处理data = dataset[0]print(f'Dataset:{dataset}:')print(f'Number of graphs:{len(dataset)}')print(f'Number of features:{dataset.num_features}')print(f'Number of classes:{dataset.num_classes}')print(f'Number of nodes:{data.num_nodes}')print(f'Number of edges:{data.num_edges}')print(f'Average node degree:{data.num_edges / data.num_nodes}')print(f'Number of training nodes:{data.train_mask.sum()}')print(f'Training node label rate:{int(data.train_mask.sum()) / data.num_nodes}')print(f'Has isolated nodes:{data.has_isolated_nodes()}')print(f'Has self-loops:{data.has_self_loops()}')

输出：

Dataset:Cora():
Number of graphs:1
Number of features:1433
Number of classes:7
Number of nodes:2708
Number of edges:10556
Average node degree:3.8980797636632203
Number of training nodes:140
Training node label rate:0.051698670605613
Has isolated nodes:False
Has self-loops:False

5.3 试试传统MLP的效果

import torch
from torch.nn import Linear
import torch.nn.functional as F
from torch_geometric.datasets import Planetoid
from torch_geometric.transforms import NormalizeFeaturesclass MLP(torch.nn.Module):def __init__(self, hidden_channels):super(MLP, self).__init__()torch.manual_seed(520)self.lin1 = Linear(dataset.num_features, hidden_channels)self.lin2 = Linear(hidden_channels, dataset.num_classes)def forward(self, x):x = self.lin1(x)x = x.relu()x = F.dropout(x, p=0.5, training=self.training)x = self.lin2(x)return xdef train():model.train()optimizer.zero_grad()out = model(data.x)loss = criterion(out[data.train_mask], data.y[data.train_mask])loss.backward()optimizer.step()return lossdef ttt():model.eval()out = model(data.x)pred = out.argmax(dim=1)test_correct = pred[data.test_mask] == data.y[data.test_mask]test_acc = int(test_correct.sum()) / int(data.test_mask.sum())return test_accif __name__ == '__main__':# 数据准备dataset = Planetoid(root='../data/Planetoid', name='Cora', transform=NormalizeFeatures())  # transform预处理data = dataset[0]# 模型建立model = MLP(hidden_channels=16)print(model)print("=" * 50)criterion = torch.nn.CrossEntropyLoss()optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)  # Define optimizer.# 迭代训练for epoch in range(1, 201):loss = train()if epoch % 20 == 0:print(f'Epoch:{epoch}, loss:{loss.item()}')# 测试print("正确率：", ttt())

输出：

MLP((lin1): Linear(in_features=1433, out_features=16, bias=True)(lin2): Linear(in_features=16, out_features=7, bias=True)
)
==================================================
Epoch:20 , loss:1.7634577751159668
Epoch:40 , loss:1.3432351350784302
Epoch:60 , loss:0.8805856108665466
Epoch:80 , loss:0.6011439561843872
Epoch:100 , loss:0.612098753452301
Epoch:120 , loss:0.6141201853752136
Epoch:140 , loss:0.4915192723274231
Epoch:160 , loss:0.45700499415397644
Epoch:180 , loss:0.4424014687538147
Epoch:200 , loss:0.32399505376815796
正确率： 0.53

5.4 再看看GCN的效果

import torch
from torch_geometric.nn import GCNConv
import torch.nn.functional as F
from torch_geometric.datasets import Planetoid
from torch_geometric.transforms import NormalizeFeaturesclass GCN(torch.nn.Module):def __init__(self, hidden_channels):super(GCN, self).__init__()torch.manual_seed(520)self.conv1 = GCNConv(dataset.num_features, hidden_channels)self.conv2 = GCNConv(hidden_channels, dataset.num_classes)def forward(self, x, edge_index):x = self.conv1(x, edge_index)x = x.relu()x = F.dropout(x, p=0.5, training=self.training)x = self.conv2(x, edge_index)return xdef train():model.train()optimizer.zero_grad()out = model(data.x, data.edge_index)loss = criterion(out[data.train_mask], data.y[data.train_mask])loss.backward()optimizer.step()return lossdef ttt():model.eval()out = model(data.x, data.edge_index)pred = out.argmax(dim=1)test_correct = pred[data.test_mask] == data.y[data.test_mask]test_acc = int(test_correct.sum()) / int(data.test_mask.sum())return test_accif __name__ == '__main__':# 数据准备dataset = Planetoid(root='../data/Planetoid', name='Cora', transform=NormalizeFeatures())  # transform预处理data = dataset[0]# 模型建立model = GCN(hidden_channels=16)print(model)print("=" * 50)criterion = torch.nn.CrossEntropyLoss()optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)  # Define optimizer.# 迭代训练for epoch in range(1, 201):loss = train()if epoch % 20 == 0:print(f'Epoch:{epoch}, loss:{loss.item()}')# 测试print("正确率：", ttt())

输出：

GCN((conv1): GCNConv(1433, 16)(conv2): GCNConv(16, 7)
)
==================================================
Epoch:20 , loss:1.7255724668502808
Epoch:40 , loss:1.3229681253433228
Epoch:60 , loss:0.9705381989479065
Epoch:80 , loss:0.7201246619224548
Epoch:100 , loss:0.5934590697288513
Epoch:120 , loss:0.4580436646938324
Epoch:140 , loss:0.4311455488204956
Epoch:160 , loss:0.4086465537548065
Epoch:180 , loss:0.3476596772670746
Epoch:200 , loss:0.32204487919807434
正确率： 0.813

可以看出，使用GCN的准确率为81%，使用MLP的准确率为59%，提高了22%

---

六、构建自己的图数据集

import torch
from torch_geometric.data import Dataif __name__ == '__main__':# 定义节点特征向量x和标签yx = torch.tensor([[2, 1], [5, 6], [3, 7], [12, 0]], dtype=torch.float)y = torch.tensor([0, 1, 0, 1], dtype=torch.float)# 定义边edge_index = torch.tensor([[0, 1, 2, 0, 3],  # 起始点[1, 0, 1, 3, 2]], dtype=torch.long)  # 终止点# 定义train_masktrain_mask = [(True if d is not None else False) for d in y]# 构建datadata = Data(x=x, y=y, edge_index=edge_index, train_mask=train_mask)print("data:", data)print("train_mask:", data.train_mask)

输出：

data: Data(x=[4, 2], edge_index=[2, 5], y=[4], train_mask=[4])
train_mask: [True, True, True, True]

上面的例子中，只构建了一张图，如果需要构建很多图，则重复操作即可。
最后将所有图放到一个list列表里就可以了

---

七、基于图神经网络的电商购买预测实例

7.1 数据集介绍

未完待续......

【图神经网络实战】深入浅出地学习图神经网络GNN（上）相关推荐

1. 【图神经网络实战】深入浅出地学习图神经网络GNN（下）

   文章目录 一.Graph Attention Network 1.1 图注意力机制作用与方法 1.2 Attention计算 1.3 Graph Attention 做了什么 二.序列图神经网络TGC ...

2. python神经网络教程16_Python深度学习之神经网络视频

   Python深度学习之神经网络视频 课程简介 该阶段是深度学习的入门课程,主要介绍经典的深度学习框架TensorFlow的使用,IO操作,以及神经网络基础.卷积神经网络的相关知识,并用卷积神经网络原理 ...

3. 【干货书】图机器学习，带你学习图数据的机器学习处理技术与实战案例

   来源:专知 本文为书籍推荐,建议阅读5分钟读完这本机器学习的书,你将学习图论的基本概念和所有用于构建成功的机器学习应用程序的算法和技术. 图机器学习将向您介绍一组用于处理网络数据的工具,并利用实体之间 ...

4. 神经网络实战--使用迁移学习完成猫狗分类

   前言: Hello大家好,我是Dream. 今天来学习一下如何使用基于tensorflow和keras的迁移学习完成猫狗分类,欢迎大家一起前来探讨学习~ 本文目录: 一.加载数据集 1.调用库函数 2 ...

5. python神经网络训练_Python深度学习训练神经网络

   我们现在将学习如何训练神经网络.我们还将学习反向传播算法和Python深度学习中的反向传递. 我们必须找到神经网络权重的最佳值以获得所需的输出.为了训练神经网络,我们使用迭代梯度下降法.我们最初从权重 ...

6. GCN实战深入浅出图神经网络第五章：基于Cora数据集的GCN节点分类 代码分析

   GCN实战深入浅出图神经网络第五章:基于Cora数据集的GCN节点分类 代码分析 文章目录 GCN实战深入浅出图神经网络第五章:基于Cora数据集的GCN节点分类 代码分析 SetUp,库声明 数据准 ...

7. 图表示学习+图神经网络：破解AI黑盒，揭示万物奥秘的钥匙！

   点击上方"小白学视觉",选择加"星标"或"置顶" 重磅干货,第一时间送达 从电信网络到社交网络,从经济网络到生物医学网络--图结构的数据无处 ...

8. 【赠书】图表示学习+图神经网络：破解AI黑盒，揭示万物奥秘的钥匙！

   ‍‍ 从电信网络到社交网络,从经济网络到生物医学网络--图结构的数据无处不在. 如何提取图的特征,表示或编码图的结构,基于图数据进行学习.推理和归纳变得越来越重要. 因为无论是进行数据挖掘.分析社交网 ...

9. 【Pytorch神经网络实战案例】21 基于Cora数据集实现Multi_Sample Dropout图卷积网络模型的论文分类

   Multi-sample Dropout是Dropout的一个变种方法,该方法比普通Dropout的泛化能力更好,同时又可以缩短模型的训练时间.XMuli-sampleDropout还可以降低训练集和 ...

最新文章

1. node 获取表单数据 为空_数据结构与算法(python)单向循环链表
2. oracle 11 导入到 10,oracle11g导入到10g
3. centos7.1 postgresql10+postgis2.5离线安装
4. 微擎在线goto解密系统
5. bind(),live(),delegate(),on()绑定事件方式
6. 汇总Eclipse快捷键
7. Java--I/O输入输出流
8. SQL Server里面如何导出包含数据的SQL脚本
9. liunx下安装tomcat7.0.82
10. linux iconv命令详解,iconv命令
11. 基于junit4的关于个人所得税计算的等价类与边界值_微服务的未来——从单体服务角度看微服务与云计算DevOps结合的演进...
12. findbug规则说明
13. 教你如何弹好吉他-合理的安排你的练习时间
14. c语言水仙花数作业,c语言水仙花数(c语言水仙花数的编程)
15. palette gef_GEF走向3D
16. pygame--图片随键盘移动
17. 图形处理之网格平滑vtkSmoothPolyDataFilter
18. c语言中用递推法解决渔夫问题,递归、递推 - IT小冰的个人空间 - OSCHINA - 中文开源技术交流社区...
19. 计算机视觉（ComputerVision, CV）相关领域的网站链接
20. 【网络安全】文件上传漏洞 详解

热门文章

1. Linux基础命令及常用快捷键
2. Oracle收集cbo统计信息,Oracle CBO 统计信息的收集与执行计划的选择
3. 通过yarn命令查看日志
4. 如何在零件层隐藏/显示SOLIDWORKS尺寸？
5. 个推的推送消息延迟的一个原因记录
6. 沃尔沃车载电脑怎么升级鸿蒙,沃尔沃汽车导航地图自主更新流程
7. 专业C/C++程序员的培养路线
8. UI自动化结合图像识别的例子
9. C# Html转PDF 用itextsharp把Html转PDF 完整版
10. 解决“Spark context stopped while waiting for backend“ issue