Paddle Graph Learning (PGL)图学习之图游走类deepwalk、node2vec模子[系列 ...

更多详情参考：Paddle Graph Learning 图学习之图游走类模子系列四
https://aistudio.baidu.com/aistudio/projectdetail/5002782?contributionType=1
相关项目参考：
关于图计算&图学习的基础知识概览：前置知识点学习（PGL）系列一 https://aistudio.baidu.com/aistudio/projectdetail/4982973?contributionType=1
图机器学习(GML)&图神经网络(GNN)原理和代码实现(前置学习系列二）：https://aistudio.baidu.com/aistudio/projectdetail/4990947?contributionType=1
图学习【参考资料1】词向量word2vec https://aistudio.baidu.com/aistudio/projectdetail/5009409?contributionType=1
图学习【参考资料2】-知识补充与node2vec代码注解 https://aistudio.baidu.com/aistudio/projectdetail/5012408?contributionType=1

1.图游走类算法原理前言

1.1 Graph Embedding

在开始介绍图游走算法之前，先来学习一下什么是Graph Embedding。
图嵌入是一种将图数据（通常为高维稠密的矩阵）映射为低微稠密向量的过程，如下图所示。图嵌入需要捕捉到图的拓扑布局，顶点与顶点的关系，以及其他的信息 （如子图，连边等）。如果有更多的信息被体现出来，那么卑鄙的任务将会得到更好的体现。在嵌入的过程中存在着一种共识：向量空间中保持毗连的节点相互靠近。

总的来说图嵌入技术大致可以分为两种：节点嵌入和图嵌入。

• 当需要对节点进行分类，节点相似度预测，节点分布可视化时一般接纳节点的嵌入；
  
• 当需要在图级别（graph-level）上进行预测大概整个图布局决定，需要将整个图体现为一个向量进行嵌入体现。
  

图学习的方法，大部门都可以应用到图嵌入问题中，所以图嵌入问题属于图学习中的一个非常重要的应用领域，不同的方法涉及了多方面知识。
我们可以将图嵌入的这些方法简要分为以下这些种别：
基于矩阵分解传统方法基于游走计谋基于游走计谋和其他信息基于深度学习基于GANLaplacian EigenmapsdeepwalkCENEGCNGraphGANLocally Linear Embeddingnode2vecCANESDNEANEGraph Factorizationstruc2vecTrans-NetLINEGraRepGraphSAGE 1.1.1 为什么要使用图嵌入（graph embedding）

图是一种简朴、易于明确的体现情势，但是由于下面的原因，我们需要对图进行嵌入体现：

• 在graph上直接进行机器学习具有一定的范围性，我们都知道图是由节点和边构成，这些向量关系一般只能使用数学，统计大概特定的子集进行体现，但是嵌入之后的向量空间具有更加机动和丰富的计算方式。
  
• 图嵌入能够压缩数据， 我们一般用邻接矩阵形貌图中节点之间的毗连。 毗连矩阵的维度是                                        ∣                            V                            ∣                            ×                            ∣                            V                            ∣                                  |V| \times|V|                     ∣V∣×∣V∣，其中                                        ∣                            V                            ∣                                  |V|                     ∣V∣ 是图中节点的个数。矩阵中的每一列和每一行都代表一个节点。矩阵中的非零值体现两个节点已毗连。将邻接矩阵用用大型图的特性空间险些是不大概的。一个具有1M节点和1M                                         ×                                  \times                     × 1M的邻接矩阵的图该怎么体现和计算呢？但是嵌入可以看做是一种压缩技术，能够起到降维的作用。
  
• 向量计算比直接在图上利用更加的简朴、快捷
  

但是图嵌入也需要满意一定的要求

• 学习属性的选择：不同的向量化体现方法，都是对网络信息的一种择要。有时我们会倾向于生存网络中节点的近邻关系，有时倾向学习节点在网络中的脚色（比如中心节点）。不同的应用对“学习属性”的选择有不同的要求，故而引发了各类算法的发作。
  
• 规模化：现实应用中有许多网络包含了大量的节点和边，高效的向量化方法，能够在短时间内处理超大规模的网络，才比较有实际应用的大概性。
  
• 向量维度：怎样确定合适的向量体现维度，是一个很难的问题，而且也是和具体场景相关的。事实上，越高的维度大概带来越好的结果，但是会极大降低应用性能。平衡性能和结果，在不同的应用中需要因地制宜。
  

1.2 词语嵌入方法(word2vec)

node2vec是节点嵌入方法中的代表，而节点的嵌入方法借鉴了自然语言处理（NLP）中很一个重要的方法——word2vec。更多资料可以参考词向量word2vec
该方法能够建立的焦点原因是：图中的节点和语料库中的单词的分布都依照幂定律，我们可以利用基于大量数据的学习方法来找出节点之间、单词之间的规律。

图游走算法：在图上进行游走得到游走序列，通过图体现学习利用节点之间的关系得到节点的一维体现，进而用这些一维体现进行卑鄙人物。
图游走类算法的目标，就是学习出图中每一个节点的低维体现，称为 Node Embeddings，在得到这些 embeddings 之后，就可以利用这些低维体现来进行接下来的卑鄙任务，比如节点分类之类的等等。
为什么可以用这个低维体现来做卑鄙任务呢？
代码语言：txt
复制

1. 因为可以利用一些方法，使得每个节点的 embeddings 可以学习到节点跟它的邻居的关系，更好的表示图结构和图特征的信息。

复制代码

图游走算法最先参考的是NLP的Word2vec模子，Word2vec模子的其中一种方法是Skip Gram，即根据中心词预测上下文，之后通过负采样的方式进行优化。
将Word2vec的思想和图结合起来就会得到了图游走类算法
算法思想
假设，如果只给出苹果这一个词，而没有其他的信息，那么，这个词的词义其实是含糊的。由于苹果大概指的是水果，又大概是手机，但如果给出有关于苹果的许多个句子：通过多个句子的上下文，其实可以大概相识到，上面所展示的苹果这个词的语义，是一种水果、一种食品。通过这个例子，可以得出如许的一个结论，即词的语义由其上下文决定。Word2vec 其实就是利用了如许的一个思想。
团体架构
Word2vec 模子，可以简朴的明确为 Skip Gram + 负采样

1.1.1 Skip Gram模子——根据中心词预测上下文

在Word2vec 中，提出了两种模子布局用于学习词向量，分别是 CBOW 和 Skip Gram。由于图游走类算法用的多是 skip-gram 模子，因此这里只介绍 skip-gram 模子。Skip Gram的目标很简朴，就是根据中心词，预测对应中心词的上下文词。如许做不但仅能够利用了词共现关系，同时也体现了 Word2vec的本质，即词的语义由其上下文来决定。
以下面这张图片的句子为例，假设 neighbors 为中心词，同时我们设置了window size为3. 这个窗口大小体现左右两边的上下文词数，因此 neighbors 的 context 为 uniformly from the，以及 of the last。

Skip gram 的模子布局很简朴，输入层就是中心词的 one hot 体现，经过中心一个投影层后，在输出层预测对应的context word，因此最后一层就是一个softmax分类层。
需要补充的一点是，使用 Skipgram语言模子的本质并不是为了说多么准确的预测 context words，而是为了得到模子的副产物，也就是词向量。
通常在训练结束后，隐层的权重 W 会作为词向量矩阵。
Word2Vec模子实际上分为了两个部门：

• 第一部门为建立模子得到隐层参数，
  
• 第二部门是通过模子获取嵌入词向量。
  

Word2Vec的整个建模过程实际上与自编码器（auto-encoder）的思想很相似，即先基于训练数据构建一个神经网络，当这个模子训练好以后，我们并不会用这个训练好的模子处理新的任务，我们真正需要的是这个模子通过训练数据所学得的参数，例如隐层的权重矩阵——背面我们将会看到这些权重在Word2Vec中实际上就是我们试图去学习的“word vectors”。基于训练数据建模的过程，我们给它一个名字叫“Fake Task”，意味着建模并不是我们终极的目标。
   上面提到的这种方法实际上会在无监督特性学习（unsupervised feature learning）中见到，最常见的就是自编码器（auto-encoder）：通过在隐层将输入进行编码压缩，继而在输出层将数据解码恢复初始状态，训练完成后，我们会将输出层“砍掉”，仅生存隐层。
  我们在上面提到，训练模子的真正目标是得到模子基于训练数据学得的隐层权重。为了得到这些权重，我们起首要构建一个完整的神经网络作为我们的“Fake Task”，背面再返回来看通过“Fake Task”我们怎样间接地得到这些词向量。
模子的输出概率代表着到我们词典中每个词有多大大概性跟input word同时出现。举个栗子，如果我们向神经网络模子中输入一个单词“Soviet“，那么终极模子的输出概率中，像“Union”， ”Russia“这种相关词的概率将远高于像”watermelon“，”kangaroo“非相关词的概率。由于”Union“，”Russia“在文本中更大大概在”Soviet“的窗口中出现。
我们将通过给神经网络输入文本中成对的单词来训练它完成上面所说的概率计算。下面的图中给出了一些我们的训练样本的例子。
我们选定句子“The quick brown fox jumps over lazy dog”，设定我们的窗口大小为2，也就是说我们仅选输入词前后各两个词和输入词进行组合。下图中，蓝色代表input word，方框内代表位于窗口内的单词。

我们的模子将会从每对单词出现的次数中习得统计结果。例如，我们的神经网络大概会得到更多类似（“fox”，“quick”）如许的训练样本对，而相对而言，对于（“fox”，“lazy”）如许的组合却看到的很少。因此，当我们的模子完成训练后，给定一个单词“fox”作为输入，输出的结果中“quick”大概“jumps”要比“lazy”被赋予更高的概率。可以看到，我们总是以中心词放在第一个位置，然后跟着我们的前后相邻词。可以看到，每一对词都是一个输入和一个输出组成的数据对(X,Y)。其中，X是feature，Y是label。
我们都知道神经网络只能接受数值输入，我们不大概把一个单词字符串作为输入，因此我们得想个办法来体现这些单词。最常用的办法就是基于训练文档来构建我们自己的词汇表（vocabulary）再对单词进行one-hot编码。模子的输入如果为一个10000维的向量，那么输出也是一个10000维度（词汇表的大小）的向量，它包含了10000个概率，每一个概率代表着当前词是输入样本中output word的概率大小。
我们把如许的词组对分别体现成one-hot向量，input word的向量作为Fake Task网络的输入，output word的向量作为学习的目标。

如许，我们基于成对的单词来对神经网络进行训练，训练样本是 ( input word, output word ) 如许的单词对，input word和output word都是one-hot编码的向量。终极模子的输出是一个概率分布。
如果我们现在想用300个特性来体现一个单词（即每个词可以被体现为300维的向量）。那么隐层的权重矩阵应该为10000行，300列（隐层有300个结点）。

Fake Task的训练过程，我们终极的目标就是学习这个隐层的权重矩阵。
这个隐层的权重矩阵，便成了一个“查找表（lookup table）”，进行矩阵计算时，直接去查输入向量中取值为1的维度下对应的那些权重值。隐层的输出就是每个输入单词的“嵌入词向量”。
Word2Vec模子
经过神经网络隐层的计算，ants这个词会从一个1 x 10000的向量酿成1 x 300的向量，再被输入到输出层。输出层是一个softmax回归分类器，它的每个结点将会输出一个0-1之间的值（概率），这些所有输出层神经元结点的概率之和为1。
现在，我们拥有10000个单词的词汇表，我们如果想嵌入300维的词向量，那么我们的输入-隐层权重矩阵和隐层-输出层的权重矩阵都会有 10000 x 300 = 300万个权重，在如此庞大的神经网络中进行梯度降落是相当慢的。更糟糕的是，你需要大量的训练数据来调解这些权重而且制止过拟合。百万数量级的权重矩阵和亿万数量级的训练样本意味着训练这个模子将会是个灾难。
Word2Vec论文提出了三个创新点：

• 将常见的单词组合（word pairs）大概词组作为单个“words”来处理。
  
• 对高频次单词抽样来减少训练样本的个数。
  
• 对优化目标接纳“negative sampling”方法，如许每个训练样本的训练只会更新一小部门的模子权重，从而降低计算负担。
  

更多资料可以参考词向量word2vec
1.1.2 Negative Sampling——负采样

假设，给定中心词 orange，预测其上下文词中的 juice：

Softmax 层在 Skipgram 模子中是用来计算词表的概率的。
为了能够预测出 juice，不但要预测它的概率，还要预测整个词表中所有单词的概率。但如许做的计算量黑白常大的，因此，这里使用负采样的方法进行优化。
负采样的思想很简朴。将中心词和对应的上下文词作为正样本，比如这里的 (orange, juice)。同时，选取一定命量的负样本，比如3个。
确定要正样本和负样本之后，就不再需要计算所有词的概率，而只需要对这几个样本进行分类，如果 Y=1，意味着是正样本，Y=0，意味着是负样本。从而减少了计算量。
也就是把 softmax 层修改为了多个 sigmoid 函数，从而大大减少了计算量和参与权重更新的参数数目。
1.1.3 应用到图嵌入领域

近朱者赤，近墨者黑。
也就是说，周遭的情况对于我们来说会有一定的影响，因此也可以体现为，图中的节点会受到其邻人的影响。
固然，这种情况也不但仅只存在社交网络这个范围内，在许多其他的图，比如保举系统等等，节点都会受到邻人的影响。
这也是为什么可以将Word2vec这个方法迁移到图嵌入领域的原因
2.DeepWalk（原理+实践）

游走模子的鼻祖是DeepWalk模子，它也是第一个将 NLP 领域的思想运用到图嵌入领域的模子。
2.1 节点嵌入方法（Node embeddings）

起首为什么要用DeepWalk。我们可以观察到，Word2Vec中，处理的是语句数据，词语之间只有前后之间的接洽，可以很自然的将句子中的词语分成不同的词组。但是在图数据中，节点与节点之前的接洽——边，边的构成使得图数据能够比语句数据构成节点之间更加复杂的关系。通过游走计谋，我们可以将一个复杂的图数据转换为多个之后前后关联的链路数据。

DeepWalk通过随机游走(truncated random walk)学习出一个网络的体现，在网络标注顶点很少的情况也能得到比较好的结果。随机游走起始于选定的节点，然后从当前节点移至随机邻人，并执行一定的步数，该方法大致可分为四个步调：

• 图a展示了原始的用户行为序列。
  
• 图b基于这些用户行为序列构建了物品相关图，可以看出，物品A，B之间的边产生的原因就是由于用户U1先后购买了物品A和物品B，所以产生了一条由A到B的有向边。如果后续产生了多条相同的有向边，则有向边的权重被增强。在将所有效户行为序列都转换成物品相关图中的边之后，全局的物品相关图就建立起来了。
  
• 图c接纳随机游走的方式随机选择起始点，重新产生物品序列。
  
• 图d终极将这些物品序列输入word2vec模子，天生终极的物品Embedding向量。
  

在上述DeepWalk的算法流程中，焦点是第三步，其中唯一需要情势化界说的是随机游走的跳转概率，也就是到达节点                                             v                            i                                       v_i                  vi​后，下一步遍历                                             v                            i                                       v_i                  vi​的临接点                                             v                            j                                       v_j                  vj​的概率。如果物品的相关图是有向有权图，那么从节点                                             v                            i                                       v_i                  vi​跳转到节点                                             v                            j                                       v_j                  vj​的概率界说如下：
$$P(v*{j}|v*{i})=\left{\begin{matrix}
\frac{M*{ij}}{\sum*{j\in N*+(v*{i})}M*{ij}} & , v*{j} \in N*+(v*{i}),\
0&, e_{ij}\notin \varepsilon
\end{matrix}\right.$$
其中                                   N                         ∗                         +                         (                                   v                            i                                  )                              N*+(v_i)                  N∗+(vi​)是节点                                             v                            i                                       v_i                  vi​所有的出边聚集，                                   M                         ∗                                   i                            j                                       M*{ij}                  M∗ij是节点                                             v                            i                                       v_i                  vi​到节点                                             v                            j                                       v_j                  vj​边的权重。
如果物品相关图是无相无权重图，那么跳转概率将是上面公式的一个特例，即权重                                   M                         ∗                                   i                            j                                       M*{ij}                  M∗ij将为常数1，且                                   N                         ∗                         +                         (                                   v                            i                                  )                              N*+(v_i)                  N∗+(vi​)应是节点                                             v                            i                                       v_i                  vi​所有“边”的聚集，而不是所有“出边”的聚集。
DeepWalk通过随机游走去可以获图中点的局部上下文信息，因此学到的体现向量反映的是该点在图中的局部布局，两个点在图中共有的邻近点（大概高阶邻近点）越多，则对应的两个向量之间的隔断就越短
团体架构
DeepWalk就相当于随机游走+Skip Gram+负采样的结合

与 Word2vec 的不同，其实就是多了一个采样节点序列的随机游走部门。因此这两者实现起来其实黑白常类似的。
在DeepWalk中，将每个节点看作是单词，节点序列看作是句子。如下图

Random Walk
不同于NLP中可以获取许多的语料，DeepWalk接纳了随机游走的方法来获取节点序列（可转头的深度优先搜索）。下式中的π是节点的转移概率分布，Z是归一化系数，在DeepWalk中可以明确成转移到每一个邻人节点的概率都是相同的。
具体过程

从图中的某个节点出发，游走的每一步都从与当前节点相连的边中随机选择一条，沿着选定的边移动到下一个顶点，不断重复这个过程，直到得到的序列无法继承往下走大概到达指定最大长度。
在走了多趟之后，便可以得到多个游走序列，此时就可以类比 NLP 中的句子了。
随机游走的本质，其实就是可以“转头”的深度优先搜索
DeepWalk选取随机游走序列中下一个节点的方式是均匀随机分布的，因此对于与当前节点有边相连的节点，都有相同的概率被选择。
在 DeepWalk 中，会针对图中的每个节点采样多条序列，得到这些节点序列之后，就可以直接套用 Word2vec 模子了。
2.2 DeepWalk代码实现

代码语言：import numpy as np
复制

1. %matplotlib inline
2. import matplotlib.pyplot as plt
3. import networkx as nx # networkx是一个常用的绘制复杂图形的Python包。
4. import pgl
5. def build_graph():
6.     # 定义节点的个数；每个节点用一个数字表示，即从0~9
7.     num_node = 10
8.     # 添加节点之间的边，每条边用一个tuple表示为: (src, dst)
9.     edge_list = [(2, 0), (2, 1), (3, 1),(4, 0), (0, 5),
10.              (6, 0), (6, 4), (5, 6), (7, 0), (1, 7),
11.              (2, 7), (7, 3), (8, 0), (9, 7)]
13.     g = pgl.graph.Graph(num_nodes = num_node, edges = edge_list)
15.     return g
17. # 创建一个图对象，用于保存图网络的各种数据。
18. g = build_graph()
20. def display_graph(g):
21.     nx_G = nx.Graph()
22.     nx_G.add_nodes_from(range(g.num_nodes))
23.     nx_G.add_edges_from(g.edges)
24.    
25.     pos = nx.spring_layout(nx_G, iterations=50)
26.    
27.     nx.draw(nx_G,
28.             pos,
29.             with_labels=True,
30.             node_color=['y','g','g','g','y','y','y','g','y','g'],
31.             node_size=1000)
33.     plt.show()
35. display_graph(g)
37. def deepwalk(graph, start_node, walk_len):
38.     walk = [start_node] # 初始化游走序列
40.     for d in range(walk_len): # 最大长度范围内进行采样
41.         current_node = walk[-1]
42.         successors = graph.successor(np.array([current_node])) # graph.successor: 获取当前节点的后继邻居
43.         print("当前节点: %d" % current_node)
44.         print("后继邻居", successors[0])
45.         succ = successors[0]
46.         if len(succ) == 0:
47.             break
48.         next_node = np.random.choice(succ, 1)
49.         walk.extend(next_node)
50.         
51.     return walk

复制代码

代码语言：# %%writefile userdef_graph.py
复制

1. from pgl.graph import Graph
3. import numpy as np
5. class UserDefGraph(Graph):
6.     def random_walk(self, nodes, walk_len):
7.         """
8.         输入：nodes - 当前节点id list (batch_size,)
9.              walk_len - 最大路径长度 int
10.         输出：以当前节点为起点得到的路径 list (batch_size, walk_len)
12.         用到的函数
13.         1. self.successor(nodes)
14.            描述：获取当前节点的下一个相邻节点id列表
15.            输入：nodes - list (batch_size,)
16.            输出：succ_nodes - list of list ((num_successors_i,) for i in range(batch_size))
17.         2. self.outdegree(nodes)
18.            描述：获取当前节点的出度
19.            输入：nodes - list (batch_size,)
20.            输出：out_degrees - list (batch_size,)
21.         """
22.         walks = [[node] for node in nodes]   # 首先获得当前节点列表对应的一个向量
24.         walks_ids = np.arange(0, len(nodes))  # 游走路径中节点对应id号
25.         cur_nodes = np.array(nodes)          # 当前节点情况
26.         for l in range(walk_len):   # 根据游走长度进行遍历--破出条件：1. range结束；2. outdegree==0【出度为零，没有可继续的节点】
27.             """选取有下一个节点的路径继续采样，否则结束"""
28.             outdegree = self.outdegree(cur_nodes)  # 计算当前节点的出度--也就是对应有哪些位置的邻近节点
29.             walk_mask = (outdegree != 0)           # 根据出度来确定掩码--True， False--将出度为0的部分复制为False，反之True
30.             if not np.any(walk_mask):              # 判断是否没有可继续的节点情况--出度为0
31.                break
32.             cur_nodes = cur_nodes[walk_mask]       # 根据掩码获取可继续前进的节点，作为后边讨论的当前可前行节点
33.             walks_ids = walks_ids[walk_mask]       # 获取掩码下，原节点id，组成新的work_ids用于后边讨论，但本身还是作为一个节点的标记，对应这是第几个节点
34.             outdegree = outdegree[walk_mask]       # 根据掩码获取相应的不为0的出度--用于后边计算前行的路径
36.             ######################################
37.             # 请在此补充代码采样出下一个节点
38.             '''
39.                [注解有点多，所以放外边了]
40.                PS:
41.                  1. successor 可获取当前节点的下一个相邻节点id列表，
42.                     那么successor 计算出下一节点的集合后，我们需要从中随机取出一个节点--所以我们要创建随机采样的index_list（索引序列集）
43.                  2. 创建index_list=>为了才到合适的index信息，采用np.floor与np.random,rand()实现：
44.                     eg: np.floor(np.random.rand(outdegree.shape[0]) * outdegree).astype('int64')
45.                         np.random.rand(outdegree.shape[0]): 根据出度集的形状来取得相应形状的随机数--这里体现游走的随机性
46.                         np.random.rand(outdegree.shape[0]) * outdegree：利用生成的随机数与出度集对应元素相乘——这里得到一些列的随机数，随机数范围在0~最大出度值--保证路径有效
47.                         np.floor(np.random.rand(outdegree.shape[0]) * outdegree)——实现向下取整，这样就得到了相应游走路径中接下来那个点的索引
48.                     具体实例：
49.                          np.floor(np.random.rand(20) * 3).astype('int64')
50.                          result: array([0, 1, 2, 1, 0, 0, 0, 0, 1, 1, 1, 2, 0, 2, 2, 2, 2, 1, 2, 0])
51.                  3. 既然知道了随机采样的序列集了，那么接下就是分配新的游走路径了
52.                     next_nodes = []  # 用于后边存放—— 装配有下一个节点的新路径
53.                     # 参数说明：
54.                         succ_nodes：相邻节点id列表
55.                         sample_index：对应出度生成的随即索引集
56.                         walks_ids：游走路径中节点对应id号
57.                     # 接下来的循环指的是，将节点列表、随机采样序列、游走路径中节点对应id号一一对应进行填充--得到一个游走情况
58.                     for s, ind, walk_id in zip(succ_nodes, sample_index, walks_ids):
59.                         walks[walk_id].append(s[ind])    # 注意： 从开始已经知道walks=>[[], [], []]是这种形式的，这样这里的append，就很容易理解成为相应节点添加可以继续前行的节点，形成一条路径
60.                         next_nodes.append(s[ind])        # 同时获取接下来要重新讨论游走时所需的新节点--即：如：从1走到了2，从3走到了7: [[1], [3]]=>[[1, 2], [3, 7]]
61.                                                          # 接下来自然就该考虑把新的2, 7 作为下一次游走时讨论出度的节点啦
62.             '''
63.             succ_nodes = self.successor(cur_nodes)  # 返回可继续的节点集合
64.             # next_nodes = ...
65.             sample_index = np.floor(np.random.rand(outdegree.shape[0]) * outdegree).astype('int64')
66.             next_nodes = []
67.             for s, ind, walk_id in zip(succ_nodes, sample_index, walks_ids):
68.                walks[walk_id].append(s[ind])
69.                next_nodes.append(s[ind])
70.             ######################################
71.             cur_nodes = np.array(next_nodes)  # 将节点转换为np类型，方便一些操作运算--同时保证前后数据类型
72.         
73.         # 遍历完游走长度的次数，就可以返回得到的随机游走路径啦
74.         return walks

复制代码

因存在多版本问题（基于PGL1.2.1 paddle1.8），这部门的具体实现参考链接：图学习【参考资料2】-知识补充与node2vec代码注解 https://aistudio.baidu.com/aistudio/projectdetail/5012408?contributionType=1
结果展示：
代码语言：txt
复制

1. [INFO] 2022-11-11 14:28:21,009 [my_deepwalk.py:  250]:        Step 1170 DeepWalk Loss: 0.189346  0.239437 s/step.
2. [INFO] 2022-11-11 14:28:23,367 [my_deepwalk.py:  250]:        Step 1180 DeepWalk Loss: 0.186947  0.230984 s/step.
3. [INFO] 2022-11-11 14:28:25,729 [my_deepwalk.py:  250]:        Step 1190 DeepWalk Loss: 0.193626  0.233627 s/step.
4. [INFO] 2022-11-11 14:28:28,099 [my_deepwalk.py:  250]:        Step 1200 DeepWalk Loss: 0.198106  0.242671 s/step.
5. [INFO] 2022-11-11 14:28:30,539 [my_deepwalk.py:  250]:        Step 1210 DeepWalk Loss: 0.187183  0.309996 s/step.
6. [INFO] 2022-11-11 14:28:33,171 [my_deepwalk.py:  250]:        Step 1220 DeepWalk Loss: 0.189533  0.244672 s/step.
7. [INFO] 2022-11-11 14:28:35,537 [my_deepwalk.py:  250]:        Step 1230 DeepWalk Loss: 0.202293  0.232859 s/step.
8. [INFO] 2022-11-11 14:28:37,920 [my_deepwalk.py:  250]:        Step 1240 DeepWalk Loss: 0.189366  0.244727 s/step.
9. [INFO] 2022-11-11 14:28:40,450 [my_deepwalk.py:  250]:        Step 1250 DeepWalk Loss: 0.188601  0.254400 s/step.
10. [INFO] 2022-11-11 14:28:42,875 [my_deepwalk.py:  250]:        Step 1260 DeepWalk Loss: 0.191343  0.247985 s/step.
11. [INFO] 2022-11-11 14:28:45,286 [my_deepwalk.py:  250]:        Step 1270 DeepWalk Loss: 0.186549  0.255688 s/step.
12. [INFO] 2022-11-11 14:28:47,653 [my_deepwalk.py:  250]:        Step 1280 DeepWalk Loss: 0.188638  0.240493 s/step.

复制代码

代码语言：txt
复制

1. [INFO] 2022-11-11 14:29:40,063 [link_predict.py:  223]:                        Step 160 Test Loss: 0.403480 Test AUC: 0.960065
2. [INFO] 2022-11-11 14:29:42,963 [link_predict.py:  199]:        Step 170 Train Loss: 0.399953 Train AUC: 0.960795
3. [INFO] 2022-11-11 14:29:43,092 [link_predict.py:  223]:                        Step 170 Test Loss: 0.400902 Test AUC: 0.960164
4. [INFO] 2022-11-11 14:29:45,898 [link_predict.py:  199]:        Step 180 Train Loss: 0.398023 Train AUC: 0.960870
5. [INFO] 2022-11-11 14:29:46,023 [link_predict.py:  223]:                        Step 180 Test Loss: 0.399052 Test AUC: 0.960234
6. [INFO] 2022-11-11 14:29:48,816 [link_predict.py:  199]:        Step 190 Train Loss: 0.396805 Train AUC: 0.960916
7. [INFO] 2022-11-11 14:29:48,951 [link_predict.py:  223]:                        Step 190 Test Loss: 0.397910 Test AUC: 0.960275
8. [INFO] 2022-11-11 14:29:51,783 [link_predict.py:  199]:        Step 200 Train Loss: 0.396290 Train AUC: 0.960936
9. [INFO] 2022-11-11 14:29:51,913 [link_predict.py:  223]:                        Step 200 Test Loss: 0.397469 Test AUC: 0.960292

复制代码

3. node2vec（原理+实践）

3.1 node2vec原理

Node2vec是图表征学习的一个重要的算法框架。
框架图：

2016年，斯坦福大学在DeepWalk的基础上更进一步，通过调解随机游走权重的方法使graph embedding的结果在网络的同质性（homophily）和布局性（structural equivalence）中进行衡量衡量。
具体来讲，网络的“同质性”指的是隔断相近节点的embedding应该尽量近似，如下图所示，节点u与其相连的节点s1、s2、s3、s4的embedding表达应该是靠近的，这就是“同质性“的体现。“布局性”指的是布局上相似的节点的embedding应该尽量靠近，图中节点u和节点s6都是各自局域网络的中心节点，布局上相似，其embedding的表达也应该近似，这是“布局性”的体现。
DeepWalk存在的问题是比较简朴直接，而图布局往往是一个复杂布局，需要思量许多因素，在深度优先搜索方法之外，还有广度优先搜索，结合以上两种方式可以更好的探索图模子，即node2vec。

node2vec和DeepWalk相比主要修改的是转移概率分布，不同于随机游走相邻节点转移的概率相同，node2vec思量了边的权值和节点之间的隔断，具体如下：

• 为了使Graph Embedding的结果能够表达网络的同质性，在随机游走的过程中，需要让游走的过程更倾向于宽度优先搜索（BFS），由于BFS更喜好游走到跟当前节点有直接毗连的节点上，因此就会有更多同质性信息包含到天生的样本序列中，从而被embedding表达；
  
• 另一方面，为了捉住网络的布局性，就需要随机游走更倾向于深度优先搜索（DFS），由于DFS会更倾向于通过多次跳转，游走到远方的节点上，使得天生的样本序列包含更多网络的团体布局信息。
  

那么在node2vec算法中，是怎样控制BFS和DFS的倾向性的呢？主要是通过节点间的跳转概率。下图显示了node2vec算法从节点t跳转到节点v后，下一步从节点v跳转到四周各点的跳转概率。

情势化来讲，从节点v跳转到下一个节点x的概率为
                                         π                            ∗                                       V                               X                                      =                            α                            ∗                                       p                               q                                      (                            t                            ,                            x                            )                            ⋅                                       ω                                           v                                  x                                                       \pi *{VX}=\alpha* {pq}(t,x)\cdot \omega _{vx}                     π∗VX=α∗pq(t,x)⋅ωvx​
其中                                   ω                         ∗                                   v                            x                                       \omega *{vx}                  ω∗vx是边vx的权重，                                   α                         ∗                                   p                            q                                  (                         t                         ,                         x                         )                              \alpha* {pq}(t,x)                  α∗pq(t,x)的界说如下：
$$\alpha _{pq}(t,x)=\left{\begin{matrix}
\frac{1}{p} & if \ d_{tx}=0 & \
1 & if \ d_{tx}=1 & \
\frac{1} {q} & if \ d_{tx}=2 &
\end{matrix}\right.$$
其中，                                             d                                       t                               x                                                 d_{tx}                  dtx​指的是节点                                   t                              t                  t到节点                                   x                              x                  x的隔断，参数                                   p                              p                  p和                                   q                              q                  q共同控制着随机游走的倾向性。参数                                   p                              p                  p被称为返回参数（return parameter），                                   p                              p                  p越小，随机游走回节点                                   t                              t                  t的大概性越大，node2vec就更注重表达网络的同质性，参数                                   q                              q                  q被称为收支参数（in-out parameter），                                   q                              q                  q越小，则随机游走到远方节点的大概性越大，node2vec更注重表达网络的布局性，反之，当前节点更大概在附近节点游走。
上式中的p和q是算法中的超参数，通过控制两个参数来确定图的游走水平。参数p控制随机游走以多大的概率游走回上一个节点，参数q控制游走的计谋是偏向DFS还是BFS，q较大时偏向于BFS，q较小时偏向于DFS。当p=q=1时，π=w
node2vec所体现的网络的同质性和布局性在保举系统中也是可以被很直观的解释的。同质性相同的物品很大概是同品类、同属性、大概常常被一同购买的物品，而布局性相同的物品则是各品类的爆款、各品类的最佳凑单商品等拥有类似趋势大概布局性属性的物品。毫无疑问，二者在保举系统中都黑白常重要的特性表达。由于node2vec的这种机动性，以及发掘不同特性的本领，甚至可以把不同node2vec天生的embedding融合共同输入后续深度学习网络，以生存物品的不同特性信息。
因存在多版本问题（基于PGL1.2.1 paddle1.8），这部门的具体实现参考链接：图学习【参考资料2】-知识补充与node2vec代码注解 https://aistudio.baidu.com/aistudio/projectdetail/5012408?contributionType=1
结果展示：
代码语言：txt
复制

1. [INFO] 2022-11-11 14:37:32,694 [my_node2vec.py:  358]:        Step 670 Node2vec Loss: 0.184862  0.288450 s/step.
2. [INFO] 2022-11-11 14:37:35,643 [my_node2vec.py:  358]:        Step 680 Node2vec Loss: 0.180727  0.291284 s/step.
3. [INFO] 2022-11-11 14:37:39,554 [my_node2vec.py:  358]:        Step 690 Node2vec Loss: 0.169635  0.441471 s/step.
4. [INFO] 2022-11-11 14:37:42,473 [my_node2vec.py:  358]:        Step 700 Node2vec Loss: 0.172884  0.245686 s/step.
5. [INFO] 2022-11-11 14:37:45,268 [my_node2vec.py:  358]:        Step 710 Node2vec Loss: 0.161657  0.261186 s/step.
6. [INFO] 2022-11-11 14:37:48,225 [my_node2vec.py:  358]:        Step 720 Node2vec Loss: 0.167449  0.260464 s/step.
7. [INFO] 2022-11-11 14:37:51,188 [my_node2vec.py:  358]:        Step 730 Node2vec Loss: 0.172065  0.297069 s/step.
8. [INFO] 2022-11-11 14:37:54,039 [my_node2vec.py:  358]:        Step 740 Node2vec Loss: 0.168043  0.174017 s/step.

复制代码

代码语言：txt
复制

1. [INFO] 2022-11-11 14:38:49,260 [link_predict.py:  223]:                        Step 170 Test Loss: 0.454974 Test AUC: 0.954118
2. [INFO] 2022-11-11 14:38:51,997 [link_predict.py:  199]:        Step 180 Train Loss: 0.452219 Train AUC: 0.955133
3. [INFO] 2022-11-11 14:38:52,122 [link_predict.py:  223]:                        Step 180 Test Loss: 0.453069 Test AUC: 0.954312
4. [INFO] 2022-11-11 14:38:54,851 [link_predict.py:  199]:        Step 190 Train Loss: 0.450969 Train AUC: 0.955254
5. [INFO] 2022-11-11 14:38:54,978 [link_predict.py:  223]:                        Step 190 Test Loss: 0.451892 Test AUC: 0.954428
6. [INFO] 2022-11-11 14:38:57,714 [link_predict.py:  199]:        Step 200 Train Loss: 0.450440 Train AUC: 0.955305
7. [INFO] 2022-11-11 14:38:57,842 [link_predict.py:  223]:                        Step 200 Test Loss: 0.451436 Test AUC: 0.954473

复制代码

4.基于PGL2.2版本算法实现

4.1 数据集介绍

4.1.1 引文网络（Cora、PubMed、Citeseer）

引文网络，顾名思义就是由论文和他们的关系构成的网络，这些关系包括例如引用关系、共同的作者等，具有自然的图布局，数据集的任务一般是论文的分类和毗连的预测，比较流行的数据集有三个，分别是Cora、PubMed、Citeseer，它们的组成情况如图1所示，Nodes也就是数据集的论文数量，features是每篇论文的特性，数据会合有一个包含多个单词的词汇表，去除了出现频率小于10的词，但是不进行编码，论文的属性是由一串二进制码构成，只用0和1体现该论文有无这个词汇。

文件构成

• 以cora数据集为例，数据集包含两个文件，cora.cites和cora.content，cora.cites文件中的数据如下：
  

  

• 即原论文和引用的论文，刚好构成了一条自然的边，cora.content文件的数据如下：
  

  +

• 有论文id、上面说到的二进制码和论文对应的种别组成，其余两个数据集类似。
  

4.1.2 社交网络（BlogCatalog、Reddit、Epinions）

BlogCatalog数据集是一个社会关系网络，图是由博主和他（她）的社会关系（比如好友）组成，labels是博主的爱好爱好。Reddit数据集是由来自Reddit论坛的帖子组成，如果两个帖子被同一人评论，那么在构图的时间，就认为这两个帖子是相关联的，labels就是每个帖子对应的社区分类。Epinions是一个从一个在线商品评论网站网络的多图数据集，内里包含了多种关系，比如评论者对于另一个评论者的态度（信任/不信任），以及评论者对商品的评级。
文件构成
BlogCatalog数据集的结点数为10312，边条数为333983，label维度为39，数据集包含两个文件：

• Nodes.csv：以字典的情势存储用户的信息，但是只包含节点id。
  
• Edges.csv：存储博主的社交网络（好友等），以此来构图。
  

Epinions数据集包含文件如下：

• Ratings_data.txt：包含用户对于一件物品的评级，文件中每一行的布局为user_id
  
• item_id rating_value。
  
• Trust_data.txt：存储了用户对其他用户的信任状态，存储方式为source_user_id
  
• target_user_id trust_statement_value，其中信任状态只有信任和不信任（1、0）。
  

由于Reddit comments 数据集的文件太多，所以这里略过了，如果需要大概感爱好的话，可以从文末的毗连进入检察。
相关论文：
Rossi, R. A. , & Ahmed, N. K. . (2015). The Network Data Repository with Interactive Graph Analytics and Visualization. Twenty-ninth Aaai Conference on Artificial Intelligence. AAAI Press.
4.1.3.生物化学布局（PPI、NCI-1、NCI-109、MUTAG、QM9、Tox21）

代码语言：txt
复制

1. PPI是蛋白质互作网络，数据集中共有24张图，其中20张作为训练，2张作为验证，2张作为测试，每张图对应不同的人体组织，实例如图3，该数据是为了从系统的角度研究疾病分子机制、发现新药靶点等等。

复制代码

代码语言：txt
复制

1. 平均每张图有2372个结点，每个结点特征长度为50，其中包含位置基因集，基序集和免疫学特征。基因本体集作为labels（总共121个），labels不是one-hot编码。

复制代码

NCI-1、NCI-109和MUTAG是关于化学分子和化合物的数据集，原子代表结点，化学键代表边。NCI-1和NCI-109数据集分别包含4100和4127个化合物，labels是判定化合物是否有拦阻癌细胞增长得性质。MUTAG数据集包含188个硝基化合物，labels是判定化合物是芳香族还是杂芳族。
QM9数据集包括了13万有机分子的构成,空间信息及其对应的属性. 它被广泛应用于各类数据驱动的分子属性预测方法的实行和对比。
Toxicology in the 21st Century 简称tox21，任务是使用化学布局数据预测化合物对生物化学途径的干扰，研究、开发、评估和翻译创新的测试方法，以更好地预测物质怎样影响人类和情况。数据集有12707张图，12个labels。
文件构成
PPI数据集的构成：
代码语言：txt
复制

1. train/test/valid_graph.json：保存了训练、验证、测试的图结构数据。
3. train/test/valid_feats.npy ：保存结点的特征，以numpy.ndarry的形式存储，shape为[n, v]，n是结点的个数，v是特征的长度。
5. train/test/valid_labels.npy：保存结点的label，也是以numpy.ndarry的形式存储，形为n*h，h为label的长度。
7. train/test/valid/_graph_id.npy ：表示这个结点属于哪张图，形式为numpy.ndarry，例如[1, 1, 2, 1...20].。
9. NCI-1、NCI-109和MUTAG数据集的文件构成如下：（用DS代替数据集名称）
11. n表示结点数，m表示边的个数，N表示图的个数
13. DS_A.txt (m lines)：图的邻接矩阵，每一行的结构为(row, col)，即一条边。
15. DS_graph_indicator.txt (n lines)：表明结点属于哪一个图的文件。
17. DS_graph_labels.txt (N lines)：图的labels。
19. DS_node_labels.txt (n lines)：结点的labels。
21. DS_edge_labels.txt (m lines)：边labels。
23. DS_edge_attributes.txt (m lines)：边特征。
25. DS_node_attributes.txt (n lines)：结点的特征。
27. DS_graph_attributes.txt (N lines)：图的特征，可以理解为全局变量。

复制代码

代码语言：txt
复制

1. QM9的文件结构如下：

复制代码

代码语言：txt
复制

1. QM9_nano.npz：该文件需要用numpy读取,其中包含三个字段：
3. 'ID' 分子的id，如:qm9:000001；
5. 'Atom' 分子的原子构成，为一个由原子序数的列表构成,如[6,1,1,1,1]表示该分子由一个碳(C)原子和4个氢(H)原子构成.；
7. 'Distance' 分子中原子的距离矩阵,以上面[6,1,1,1,1]分子为例,它的距离矩阵即为一个5x5的矩阵,其中行列的顺序和上述列表一致,即矩阵的第N行/列对应的是列表的第N个原子信息.
9. 'U0' 分子的能量属性(温度为0K时),也是我们需要预测的值（分类的种类为13）
11. Tox21文件夹中包含13个文件，其中12个文件夹就是化合物的分类

复制代码

4.1.4 ArXiv

代码语言：txt
复制

1. http://snap.stanford.edu/data/ca-AstroPh.html

复制代码

Arxiv ASTRO-PH（天体物理学）协作网络是来自电子版预影印平台arXiv，涵盖了提交到Astro Physics种别的论文，包含了不同作者之间的科学相助信息。 如果作者i与作者j共同撰写了论文，则该图包含从i到j的无向边。 如果论文由k位作者共同撰写，则将在k个节点上天生完全毗连的（子）图。
数据涵盖了1993年1月至2003年4月（124个月）期间的论文。 它始于arXiv建立后的几个月内，因此基本上代表了其ASTRO-PH部门的完整汗青。
ArXiv数据集的结点数为18772，边条数为198110。
相关论文
J. Leskovec, J. Kleinberg and C. Faloutsos. Graph Evolution: Densification and Shrinking Diameters. ACM Transactions on Knowledge Discovery from Data (ACM TKDD), 1(1), 2007.

4.1.5 下载地址

Cora：https://s3.us-east-2.amazonaws.com/dgl.ai/dataset/cora_raw.zip
Pubmed：https://s3.us-east-2.amazonaws.com/dgl.ai/dataset/pubmed.zip
Citeseer：https://s3.us-east-2.amazonaws.com/dgl.ai/dataset/citeseer.zip
BlogCatalog：http://socialcomputing.asu.edu/datasets/BlogCatalog
Reddit：https://github.com/linanqiu/reddit-dataset
Epinions：http://www.trustlet.org/downloaded_epinions.html
PPI：http://snap.stanford.edu/graphsage/ppi.zip
NCI-1：https://ls11-www.cs.uni-dortmund.de/people/morris/graphkerneldatasets/NCI1.zip
NCI-109：https://ls11-www.cs.uni-dortmund.de/people/morris/graphkerneldatasets/NCI109.zip
MUTAG：https://ls11-www.cs.uni-dortmund.de/people/morris/graphkerneldatasets/MUTAG.zip
QM9：https://github.com/geekinglcq/QM9nano4USTC
Tox21：https://tripod.nih.gov/tox21/challenge/data.jsp
4.2deepwalk(多种别预测任务)

数据集为：BlogCatalog
Paddle2.0+是动态图了，为了进一步简化使用，将GraphWrapper的概念去掉了，现在可以直接在Graph上进行Send/Recv
代码语言：txt
复制

1. #uninstall pgl 2.1
2. python -m pip uninstall pgl
3. #install pgl 1.2.1
4. python -m pip install pgl==1.2.1

复制代码

部门结果展示：
代码语言：txt
复制

1. [INFO] 2022-11-13 22:44:29,956 [    train.py:   81]:        Batch 7990 train-Loss 0.456979
2. [INFO] 2022-11-13 22:44:30,900 [    train.py:   81]:        Batch 8000 train-Loss 0.457403
3. [INFO] 2022-11-13 22:44:31,791 [    train.py:   81]:        Batch 8010 train-Loss 0.456784
4. [INFO] 2022-11-13 22:44:32,675 [    train.py:   81]:        Batch 8020 train-Loss 0.453279
5. [INFO] 2022-11-13 22:44:33,593 [    train.py:   81]:        Batch 8030 train-Loss 0.455351
6. [INFO] 2022-11-13 22:44:34,529 [    train.py:   81]:        Batch 8040 train-Loss 0.455643
7. [INFO] 2022-11-13 22:44:35,388 [    train.py:   81]:        Batch 8050 train-Loss 0.456534

复制代码

代码语言：txt
复制

1. 100%|███████████████████████████████████████▊| 996/1000 [01:40<00:00,  9.86it/s][INFO] 2022-11-13 22:46:22,662 [multi_class.py:  150]:        Train Loss: 0.095118 Train Macro F1: 0.440330 Train Micro F1: 0.473333
2. [INFO] 2022-11-13 22:46:22,710 [multi_class.py:  187]:                        Test Loss: 0.124781 Test Macro F1: 0.224703 Test Micro F1: 0.367081
3. 100%|███████████████████████████████████████▉| 997/1000 [01:41<00:00,  9.88it/s][INFO] 2022-11-13 22:46:22,763 [multi_class.py:  150]:        Train Loss: 0.095118 Train Macro F1: 0.440330 Train Micro F1: 0.473333
4. [INFO] 2022-11-13 22:46:22,812 [multi_class.py:  187]:                        Test Loss: 0.124784 Test Macro F1: 0.224703 Test Micro F1: 0.367081
5. 100%|███████████████████████████████████████▉| 998/1000 [01:41<00:00,  9.88it/s][INFO] 2022-11-13 22:46:22,864 [multi_class.py:  150]:        Train Loss: 0.095117 Train Macro F1: 0.440330 Train Micro F1: 0.473333
6. [INFO] 2022-11-13 22:46:22,913 [multi_class.py:  187]:                        Test Loss: 0.124788 Test Macro F1: 0.224703 Test Micro F1: 0.367081
7. 100%|███████████████████████████████████████▉| 999/1000 [01:41<00:00,  9.89it/s][INFO] 2022-11-13 22:46:22,965 [multi_class.py:  150]:        Train Loss: 0.095116 Train Macro F1: 0.440344 Train Micro F1: 0.473373
8. [INFO] 2022-11-13 22:46:23,013 [multi_class.py:  187]:                        Test Loss: 0.124791 Test Macro F1: 0.224703 Test Micro F1: 0.367081
9. 100%|███████████████████████████████████████| 1000/1000 [01:41<00:00,  9.89it/s]
10. [INFO] 2022-11-13 22:46:23,014 [multi_class.py:  247]:        Best test macro f1 is 0.2269956056437573.

复制代码

4.3node2vec多种别预测任务)

部门结果展示：
代码语言：txt
复制

1. [INFO] 2022-11-13 23:01:59,675 [    train.py:   81]:        Batch 3950 train-Loss 0.569241
2. [INFO] 2022-11-13 23:02:01,468 [    train.py:   81]:        Batch 3960 train-Loss 0.569519
3. [INFO] 2022-11-13 23:02:03,191 [    train.py:   81]:        Batch 3970 train-Loss 0.569199
4. [INFO] 2022-11-13 23:02:04,906 [    train.py:   81]:        Batch 3980 train-Loss 0.570791
5. [INFO] 2022-11-13 23:02:06,510 [    train.py:   81]:        Batch 3990 train-Loss 0.569951
6. [INFO] 2022-11-13 23:02:08,249 [    train.py:   81]:        Batch 4000 train-Loss 0.570624
7. [INFO] 2022-11-13 23:02:09,876 [    train.py:   81]:        Batch 4010 train-Loss 0.567852
8. [INFO] 2022-11-13 23:02:11,495 [    train.py:   81]:        Batch 4020 train-Loss 0.570603

复制代码

代码语言：txt
复制

1. 100%|███████████████████████████████████████▉| 997/1000 [01:42<00:00,  9.85it/s][INFO] 2022-11-13 23:03:59,728 [multi_class.py:  150]:        Train Loss: 0.096447 Train Macro F1: 0.352921 Train Micro F1: 0.471340
2. [INFO] 2022-11-13 23:03:59,777 [multi_class.py:  187]:                        Test Loss: 0.119648 Test Macro F1: 0.233598 Test Micro F1: 0.383243
3. 100%|███████████████████████████████████████▉| 998/1000 [01:42<00:00,  9.83it/s][INFO] 2022-11-13 23:03:59,830 [multi_class.py:  150]:        Train Loss: 0.096443 Train Macro F1: 0.352921 Train Micro F1: 0.471340
4. [INFO] 2022-11-13 23:03:59,879 [multi_class.py:  187]:                        Test Loss: 0.119651 Test Macro F1: 0.233497 Test Micro F1: 0.383210
5. 100%|███████████████████████████████████████▉| 999/1000 [01:42<00:00,  9.83it/s][INFO] 2022-11-13 23:03:59,932 [multi_class.py:  150]:        Train Loss: 0.096440 Train Macro F1: 0.352921 Train Micro F1: 0.471340
6. [INFO] 2022-11-13 23:03:59,980 [multi_class.py:  187]:                        Test Loss: 0.119654 Test Macro F1: 0.233497 Test Micro F1: 0.383210
7. 100%|███████████████████████████████████████| 1000/1000 [01:42<00:00,  9.84it/s]
8. [INFO] 2022-11-13 23:03:59,981 [multi_class.py:  247]:        Best test macro f1 is 0.2342214269132497.

复制代码

4.4 结果对比

DatasetmodelTaskMetricPGL ResultBlogCatalogdeepwalkmulti-label classificationMacroF10.2269BlogCatalognode2vecmulti-label classificationMacroF10.23422 这里使用默认的参数，需要调优一下，0.260最佳结果。.
那么，我们该怎样学习大模子？

作为一名热心肠的互联网老兵，我决定把名贵的AI知识分享给大家。 至于能学习到多少就看你的学习毅力和本领了 。我已将重要的AI大模子资料包括AI大模子入门学习头脑导图、佳构AI大模子学习册本手册、视频教程、实战学习等录播视频免费分享出来。
一、大模子全套的学习路线

学习大型人工智能模子，如GPT-3、BERT或任何其他先辈的神经网络模子，需要系统的方法和连续的努力。既然要系统的学习大模子，那么学习路线是必不可少的，下面的这份路线能帮助你快速梳理知识，形成自己的体系。
L1级别:AI大模子期间的华丽登场

L2级别：AI大模子API应用开发工程

L3级别：大模子应用架构进阶实践

L4级别：大模子微调与私有化摆设

一般掌握到第四个级别，市场上大多数岗位都是可以胜任，但要还不是天花板，天花板级别要求更加严酷，对于算法和实战黑白常苛刻的。建议普通人掌握到L4级别即可。
以上的AI大模子学习路线，不知道为什么发出来就有点糊，高清版可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】

二、640套AI大模子报告合集

这套包含640份报告的合集，涵盖了AI大模子的理论研究、技术实现、行业应用等多个方面。无论您是科研职员、工程师，还是对AI大模子感爱好的爱好者，这套报告合集都将为您提供名贵的信息和启示。

三、大模子经典PDF籍

随着人工智能技术的飞速发展，AI大模子已经成为了当今科技领域的一大热门。这些大型预训练模子，如GPT-3、BERT、XLNet等，以其强大的语言明确和天生本领，正在改变我们对人工智能的认识。 那以下这些PDF籍就黑白常不错的学习资源。

四、AI大模子商业化落地方案

作为普通人，入局大模子期间需要连续学习和实践，不断提高自己的技能和认知水平，同时也需要有责任感和伦理意识，为人工智能的康健发展贡献力量。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。