Python之DataFrame基础用法

引入库

import pandas as pd
import numpy as np

pandas官方文档：https://pandas.pydata.org/pandas-docs/stable

1.1 利用字典创建

data={"one":np.random.randn(4),"two":np.linspace(1,4,4),"three":['zhangsan','李四',999,0.1]}
df=pd.DataFrame(data,index=[1,2,3,4])
df

onetwothree11.0876811.0zhangsan2-1.7021432.0李四30.1535103.09994-0.2064734.00.1

• 如果创建df时不指定索引，默认索引将是从0开时，步长为1的数组。
• df的行、列可以是不同的数据类型，同行也可以有多种数据类型。
• df创建完成后可以重新设置索引，通常用到3个函数： set_index、 reset_index、 reindex。

df.set_index(['one'],drop=False)

onetwothreeone1.0876811.0876811.0zhangsan-1.702143-1.7021432.0李四0.1535100.1535103.0999-0.206473-0.2064734.00.1

df.index=['a','b','c','d']

df.reset_index(drop=True)

参数 drop默认值为False，意为将原来的索引做为数据列保留，如果设为True，原来的索引会直接删除。

1.2 利用数组创建

data=np.random.randn(6,4)
df=pd.DataFrame(data,columns=list('ABCD'),index=[1,2,'a','b','2006-10-1','第六行'])
df

ABCD1-1.4683700.148891-0.4633740.20106020.483324-0.518111-1.2384870.949822a-0.909020-0.111295-0.8333371.560756b-0.0349780.036142-1.6134372.0408242006-10-1-0.312716-2.481801-0.607386-0.763655第六行0.300200-0.6185870.1875570.416438

1.3 创建一个空DataFrame

pd.DataFrame(columns=('id','name','grade','class'))

2.1 按列读取

df[['A','B','D']]
df.loc[:,['A','B','D']]

ABD1-1.4683700.1488910.20106020.483324-0.5181110.949822a-0.909020-0.1112951.560756b-0.0349780.0361422.0408242006-10-1-0.312716-2.481801-0.763655第六行0.300200-0.6185870.416438

PS: df[‘A’]和 df[[‘A’]]都能读取第一列数据，但它们返回的数据结构不同：

• type(df[‘A’]): pandas.core.series.Series
• type(df[[‘A’]]): pandas.core.frame.DataFrame

df.iloc[:,2:]

CD1-0.4633740.2010602-1.2384870.949822a-0.8333371.560756b-1.6134372.0408242006-10-1-0.607386-0.763655第六行0.1875570.416438

2.2 按行读取

df.loc[['a','第六行']]

ABCDa-0.90902-0.111295-0.8333371.560756第六行0.30020-0.6185870.1875570.416438

df.iloc[1:3]

ABCD20.483324-0.518111-1.2384870.949822a-0.909020-0.111295-0.8333371.560756

2.3 按单元格读取

df.B['a']

-0.11129495036792952

• 读取一个单元格： df.loc[row][col]或 df.loc[row,col]
• 读取一行多列：

df.loc[row][[col1,col2]]
df.loc[row,[col1,col2]]
df.loc[row][firstCol:endCol]
df.loc[row,firstCol:endCol]

df.loc['a'][['B','C']]
df.loc['a','A':'C']

A   -0.909020
B   -0.111295
C   -0.833337
Name: a, dtype: float64

• 读取多行一列：

df.loc[[row1,row2]][col]
df.loc[[row1,row2]].col
df.loc[[row1,row2],col]

df.loc[[1,'a']]['C']
df.loc[[1,'a']].D
df.loc[[1,'a'],'A']

1   -1.46837
a   -0.90902
Name: A, dtype: float64

• 读取多行多列

df.loc[[row1,row2],[col1,col2]]
df.loc[[row1,row2]][[col1,col2]]
df.loc[[row1,row3],firstCol:endCol]
df.loc[[firstRow1:endRow3,firstCol:endCol]

print(df.loc[[1,'a'],['A','C']])
print(df.loc[[1,'a']][['A','C']])
df.loc[1:'a','A':'C']

         A         C
1 -1.46837 -0.463374
a -0.90902 -0.833337
         A         C
1 -1.46837 -0.463374
a -0.90902 -0.833337

ABC1-1.4683700.148891-0.46337420.483324-0.518111-1.238487a-0.909020-0.111295-0.833337

• 读取一个单元格

df.iloc[rowNo].col
df.iloc[rowNo][col]
df.iloc[rowNo,colNo]

PS：df.iloc[rowNo,col]不支持。

print(df.iloc[1].B)
print(df.iloc[1]['B'])
df.iloc[1,1]

-0.5181113354542651
-0.5181113354542651
-0.5181113354542651

• 读取一行多列

df.iloc[rowNo,firestColNo:endColNo]
df.iloc[rowNo][[col1,col2]]
df.iloc[rowNo][firesCol:endCol]

PS: df.iloc[rowNo,[col1,col2]]不支持。

print(df.iloc[1,1:])
df.iloc[1][['A','C']]
df.iloc[1]['A':'C']

B   -0.518111
C   -1.238487
D    0.949822
Name: 2, dtype: float64

A    0.483324
B   -0.518111
C   -1.238487
Name: 2, dtype: float64

• 读取多行一列

df.iloc[[rowNo1,rowNo2],colNo]
df.iloc[firstRowNo:endRowNo,colNo]
df.iloc[[rowNo1,rowNo2]][col]
df.iloc[firstRowNo:endRowNo][col]

print(df.iloc[[0,2],1])
print(df.iloc[:2,1])
print(df.iloc[[0,2]]['B'])
df.iloc[0:2]['B']

1    0.148891
a   -0.111295
Name: B, dtype: float64
1    0.148891
2   -0.518111
Name: B, dtype: float64
1    0.148891
a   -0.111295
Name: B, dtype: float64
1    0.148891
2   -0.518111
Name: B, dtype: float64

• 读取多行多列

df.iloc[firstRowNo:endRowNo,firstColNo:endColNo]
df.iloc[[RowNo1,RowNo2],[ColNo1,ColNo2]]
df.iloc[firstRowNo:endRowNo][[col1,col2]]

print(df.iloc[1:4,1:4])
print(df.iloc[[1,3],[1,3]])
df.iloc[1:4][['A','C']]

          B         C         D
2 -0.518111 -1.238487  0.949822
a -0.111295 -0.833337  1.560756
b  0.036142 -1.613437  2.040824
          B         D
2 -0.518111  0.949822
b  0.036142  2.040824

AC20.483324-1.238487a-0.909020-0.833337b-0.034978-1.613437

3.1 按列赋值

df.col=colList/colValue
df[col]=colList/colValue

eg:df.A=[1,2,3,4,5,6],df['A']=0

3.2 按行赋值

df.loc[row]=rowList/rowValue

3.3 给多行多列赋值

df.loc[[row1,row2],[col1,col2]]=value/valueList
df.iloc[[rowNo1,rowNo2],[colNo1,colNo2]]=value/valueList
df.iloc[[rowNo1,rowNo2]][[col1,col2]]=value/valueList

4.1 在任意位置插入

• 插入一列

insert(ioc,column,value)
ioc:要插入的位置即列号
colunm:列名
value:值

df.insert(1,'E',[1,2,3,4,5,6])
df

AEBCD1-1.46837010.148891-0.4633740.20106020.4833242-0.518111-1.2384870.949822a-0.9090203-0.111295-0.8333371.560756b-0.03497840.036142-1.6134372.0408242006-10-1-0.3127165-2.481801-0.607386-0.763655第六行0.3002006-0.6185870.1875570.416438

• 插入一行

row={'one':111,'two':222,'three':333}
df.loc[1]=row
df.iloc[1]=row

4.2 在末尾插入(表合并)

• 按行合并(即 LEFT JOIN)

pd.concat([df,df1],axis=1)

• 按列合并(即 UNION)

result = pd.concat([df,df2],axis=0)
OR
result = df.append(df2)

data1=np.random.randn(2,4)
df1=pd.DataFrame(data1,columns=list('EFGH'))
df1

EFGH00.257269-0.3147552.065818-1.24893611.609680-0.9421370.3850730.180102

pd.concat([df,df1],axis=1)

ABCDEFGH0NaNNaNNaNNaN0.602251-0.122802-0.064065-0.7471971-1.1780920.7899670.029976-0.3039410.3410690.1907930.073840-1.3950452-0.4075260.500577-2.187063-0.810440NaNNaNNaNNaN2006-10-1-0.7265482.500259-0.7712301.037939NaNNaNNaNNaNa0.2049471.284060-0.5018030.260510NaNNaNNaNNaNb0.5496871.2058480.2064982.123772NaNNaNNaNNaN第六行-0.882526-1.0448420.6271140.596011NaNNaNNaNNaN

data2=np.random.randn(2,5)
df2=pd.DataFrame(data2,columns=list('AEBCD'))
df2

AEBCD0-0.285998-2.167751-0.7600161.094251-0.9963601-0.3284050.248779-0.0235822.0352760.039617

del(dfo)
dfo = pd.concat([df,df2],axis=0)
dfo

AEBCD1-1.4683701.0000000.148891-0.4633740.20106020.4833242.000000-0.518111-1.2384870.949822a-0.9090203.000000-0.111295-0.8333371.560756b-0.0349784.0000000.036142-1.6134372.0408242006-10-1-0.3127165.000000-2.481801-0.607386-0.763655第六行0.3002006.000000-0.6185870.1875570.4164380-0.285998-2.167751-0.7600161.094251-0.9963601-0.3284050.248779-0.0235822.0352760.039617

df.append(df2)

AEBCD1-1.46837010.148891-0.4633740.20106020.4833242-0.518111-1.2384870.949822a-0.9090203-0.111295-0.8333371.560756b-0.03497840.036142-1.6134372.0408242006-10-1-0.3127165-2.481801-0.607386-0.763655第六行0.3002006-0.6185870.1875570.416438

5.1 删除行列

drop(labels, axis=0, level=None, inplace=False)

• lables：要删除数据的标签
• axis：0表示删除行,1表示删除列,默认0
• inplace:是否在当前df中执行此操作,否则会创建临时df

5.2 去重

df.drop_duplicates(subset=['A','B'],keep='first',inplace=True)

• subset： 输入要进行去重的列名，默认为None
• keep： 可选参数有三个：’first’、 ‘last’、 False， 默认值 ‘first’。其中，
• first表示： 保留第一次出现的重复行，删除后面的重复行。
• last表示： 删除重复项，保留最后一次出现。
• False表示： 删除所有重复项。
• inplace：是否在当前df中执行此操作,否则会创建临时df

drop_duplicates删除重复行时会同步删除索引，建议使用 reset_index(drop = True)重置索引

5.3 更改列名

• 方法一：使用rename函数更改列名

df2=df1.rename(columns={'name':'stu_name','class':'stu_class'},,inplace=True)

• 方法二：直接更改所有列名
  
  [En]

  method 2: change all column names directly*

df1.columns=['id','stu_name','stu_class']

dfo.drop(['A','B'],axis=1,inplace=True)dfo

ECD11.000000-0.4633740.20106022.000000-1.2384870.949822a3.000000-0.8333371.560756b4.000000-1.6134372.0408242006-10-15.000000-0.607386-0.763655第六行6.0000000.1875570.4164380-2.1677511.094251-0.99636010.2487792.0352760.039617

dfo.drop([1,2],axis=0)

AEBCDa-0.9090203.000000-0.111295-0.8333371.560756b-0.0349784.0000000.036142-1.6134372.0408242006-10-1-0.3127165.000000-2.481801-0.607386-0.763655第六行0.3002006.000000-0.6185870.1875570.4164380-0.285998-2.167751-0.7600161.094251-0.996360

<tr>
  <th>1</th>
  <td>0.248779</td>
  <td>2.035276</td>
  <td>0.039617</td>
</tr>

dfo.drop([1,2],axis=0)

AEBCDa-0.9090203.000000-0.111295-0.8333371.560756b-0.0349784.0000000.036142-1.6134372.0408242006-10-1-0.3127165.000000-2.481801-0.607386-0.763655第六行0.3002006.000000-0.6185870.1875570.4164380-0.285998-2.167751-0.7600161.094251-0.996360

Original: https://blog.csdn.net/doraemonjtr/article/details/125611147
Author: doraemonjtr
Title: Python之DataFrame基础用法

相关阅读

Title: 图的概念与主要类型、图模型的应用场景

图（Graph）是一个常见的数据结构，现实世界中有很多任务都可以抽象成图问题，比如社交网络，蛋白体结构，交通路网数据，以及很火的知识图谱等，甚至规则网络结构数据（如图像，视频等）也是图数据的一种特殊形式。

随着数据多样性的发展，图计算已经成为业界的一个重要的研究方向。如大规模图搜索、图数据的代表节点评价、图数据的社区划分、图数据的向量嵌入，基于图的推荐、节点预测、关系预测等实际应用需求的提出，也突出了图算法这一技术的重要性。

知识图谱本质上是一种图结构，在图内部数据规模大且质量高、外部算力足够的情况下，充分利用好图算法，能够最大程度地发挥出其数据价值。知识图谱嵌入、基于知识图谱的推荐、路径关联分析等，都会用到图算法。由于笔者近期也在学习相关的知识，现就假期中阶段性的梳理结果整理出来，分享给大家，希望大家批评指正。

图模型之用武之地：图模型的典型应用场景

目前将图算法模型应用于实际业务中已经被证明是有效的。例如，基于图的团伙挖掘、58和斗鱼直播将图算法应用于广告反作弊、直播反作弊、腾讯将算法应用于网络黑产挖掘，荔枝FM中将图算法应用于推荐、京东的9N算法框架已经被广泛应用于推荐广告、搜索广告、以及其他的站内外广告场景、微信支付基于图计算的反欺诈等。这些场景可以进一步抽象为 节点分类、路径预测、社区聚类、节点推荐等几类。其中：

1）节点分类。旨在基于其他标记的节点和网络拓扑来确定节点的标签，例如，与序列自然语言处理类似，将一个文本作为一个图的节点，可应用于主题文本分类，包括新闻分类、Q&A、搜索结果组织。在网络安全攻击中，可以通过已知具有攻击行为的站点来对未知标签的站点进行预测。

2）路径预测。指预测缺失链路或未来可能出现的链路。链路预测场景中主要完成的是对网络中的两个节点是否可能存在链路进行预测。例如，在推荐系统中，我们推荐的是高度”连接”的产品，可以用GNN训练模型来预测这种链路是否存在。

3）社区聚类。用于发现相似节点的子集，并将它们分组在一起。例如，关联关系识别团伙，无监督方法：通过连通子图算法识别出一个个连通的社区，如果社区规模较大，可能背后业务含义是黑产控制一批账户。在具体实现上，可以通过定义社区规模为score，通过调节阈值来控制误杀、召回，从而发现不同的社区及其成员。使用社区聚类的方法，也可以用于文本聚类。

4）节点推荐。根据节点特征以及其他特征进行搜索推荐。例如，在社交人物中的推荐场景中，可以通过一些图结构结合一些算法，比如典型的pagerank算法，找到关键人物，通过对关键人物采取特定性策略（比如定向推广）以提升推荐效果，也可以基于地理、人物任务关系、兴趣爱好组成的圈子，进行产品和广告的推荐。

图模型的应用已扩散到互联网实际场景中，比如阿里巴巴达摩院开发的图计算平台GraphScope，已经证明在多个关键互联网领域 （如风控，电商推荐，广告，网络安全，知识图谱等）实现了重要的业务新价值。GraphScope的代码于github.com/alibaba/graphscope 开源，仅一年时间已获得1057个用户star。GraphScope支持50余种图分析和图学习算法库，日均计算16000多项任务，同时在工业级复杂场景中支持单图100多个标签和1000余种属性，单图数据规模达到50TB，大大缩短端到端开发时间。

图模型之建模对象：图的概念与主要类型

在了解图的应用场景后，我们进一步来看下图的基本概念以及其一些更为细致的变体。”图”作为一种直观自然的数据结构，在数学上表示成G=(V, E)，在存储方式上可以用邻接矩阵、邻接表等格式进行存储，而图中包括节点和边，节点类型和边的类型不同，会形成许多各式各样的图形式。

从图的形态构成上看

可以将图分成 连通图与非连通、未加权图与加权图、有向图与无向图、非循环图和循环图等多种类型。

连通图与非连通图：连通图（Connected Graphs）指图内任意两个节点间，总能找到一条路径连接它们，否则，为非连通图（Disconnected Graphs）；

未加权图与加权图：未加权图（Unweighted Graphs）的节点和边上均没有权重，对于加权图（Weighted Graphs），所加权重可以代表成本、时间、距离、容量、甚至是指定域的优先级；

有向图与无向图：在无向图（Undirected Graphs）中，节点的关系是双向的（bi-directional），如朋友关系，而在有向图（Directed Graphs）中，节点的关系可以指定方向，边如果指向了一个节点，称为入边，边如果从一个节点出发，则称为出边；

非循环图和循环图：循环指一些特殊的路径，它们的起点和终点是同一个节点。在非循环图（Acyclic Graph）中，不存在循环路径，相反则为循环图（Cyclic Graphs）。

根据图中存储节点关系的不同

可以将分类下的图类型分为 同构图（Homogeneous graph）、二部图（Bipartile graph）和异构图（Heterogeneous graph）。

二部图中只有两种类型的节点，并且一种类型的节点只会对另一种类型的节点产生关系。如传统的推荐系统中用户与物品的形成的关系图就是二部图；

异构图中可包含多种类型节点和多种关系，相比同构图可以提供更多的信息，减少了冗余边，并且能展示更好的连接关系。比如在风险中的交易图，在交易发生过程中会使用到很多实体（图上表现为节点），除了交易本身，比如IP邮箱、邮寄地址、设备ID等都是图上的节点， 目前我们见到的知识图谱就是典型的异构图。

图模型之建模方法：图数据的典型算法

图数据如果要发挥出其价值，则需要将其结构和内容信息发挥出来。具体的，当前的图算法包括 图的路径搜索(生成)算法（用于图遍历，通过图中节点的联通，生成系列性的路径结果）、 图的中心性(重要性)计算（用于计算图中具有代表性的节点或者子图）、 图的社群发现(划分)（用于图的划分，将图划分成一个个单独的子团，进一步聚类分析）。

图的路径搜索(生成)

图搜索算法（Pathfinding and Search Algorithms）旨在探索一个图，用于一般发现或显式搜索，这些算法通过从图中找到很多路径，但并不期望这些路径是计算最优的（例如最短的，或者拥有最小的权重和），在实现上包括广度优先搜索和深度优先搜索，它们是遍历图的基础，并且通常是许多其他类型分析的第一步。路径搜索算法，具体可进一步分为DFS（深度优先遍历）、 BFS（广度优先遍历）、最短路径、最小生成树、随机游走算法等。

最短路径（Shortest Paths）算法和 随机游走算法（Random Walk）是其中的两个重要概念。

1）最短路径（Shortest Paths）算法计算给定的两个节点之间最短（最小权重和）的路径，能够给出关系传播的度数（degree）以及两点之间的最短距离，并计算两点之间成本最低的路线。这个在networkx、neo4j等图数据库中进行节点关联分析等场景中有直接应用。

2）随机游走（Random Walk）算法从图上获得一条随机的路径，该算法从一个节点开始，随机沿着一条边正向或者反向寻找到它的邻居，以此类推，直到达到设置的路径长度，一般用于随机生成一组相关的节点数据，作为后续数据处理或者其他算法使用。例如随机游走生成的序列，可以作为node2vec 和 graph2vec 算法的一部分，用于节点向量的生成，从而作为后续深度学习模型的输入，也可以作为 Walktrap 和 Infomap 算法的一部分，用于社群发现。如果随机游走总是返回同一组节点，表明这些节点可能在同一个社群，也可以作为其他机器学习模型的一部分，用于随机产生相关联的节点数据。

图的中心性(重要性)计算

图的中心性算法（Centrality Algorithms）用于识别图中特定节点的角色及其对网络的影响，能够帮助识别最重要的节点，包括节点的可信度、可访问性、事物传播的速度以及组与组之间的连接。在实现上，图的中心度算法包括DegreeCentrality、 ClosenessCentrality、BetweennessCentrality、PageRank几种。其中：

1）度中心性（Degree Centrality）表示连接到某节点的边数，一个节点的节点度越大就意味着该节点在网络中就越重要；接近中心性（Closeness Centrality）从某节点到所有其他节点的最短路径的平均长度，以此反映在网络中某一节点与其他节点之间的接近程度；介中心性（Betweenness Centrality）表示某节点在多少对节点的最短路径上，能够反映相应的节点或者边在整个网络中的作用和影响力。

2）PageRank 算法是所有的中心性算法中最为出名的一个，并在当前的网页排名，文本关键词抽取中使用十分广泛。该算法统计到节点的传入关系的数量和质量，从而决定该节点的重要性，不但考虑节点的直接影响，也考虑 “邻居” 的影响力。例如，一个节点拥有一个有影响力的 “邻居”，可能比拥有很多不太有影响力的 “邻居” 更有影响力。例如，在网页排名当中，不同的网页之间相互引用，网页作为节点，引用关系作为边，就可以组成一个网络，被更多网页引用的网页，应该拥有更高的权重；被更高权重引用的网页，也应该拥有更高权重。在文本中，通过相似度将不同的句子或者关键词作为节点进行连接，通过 PageRank思想的变体TextRank也可以得到相应重要的词语或者句子，完成关键词提取或者摘要生成的任务。

图的社群发现(划分)

社群发现算法，又称社团发现，其目标就是将节点准确地划分至不同的社团中， 形成不同的聚类簇，簇内部连边稠密、与外部连边稀疏的节点，这些聚簇也就是社团（Community），这一算法对于识别社群对于评估群体行为或突发事件十分关键。对于一个社群来说，内部节点与内部节点的关系（边）比社群外部节点的关系更多。识别这些社群可以揭示节点的分群，找到孤立的社群，发现整体网络结构关系。在具体实现上，包括MeasuringAlgorithm、ComponentsAlgorithm、 LabelPropagation Algorithm、 LouvainModularity Algorithm等算法，其中， LabelPropagation Algorithm、 LouvainModularity Algorithm算法使用较多。

1）标签传播算法是一种社群快速发现的算法，该算法认为节点的标签完全由它的直接邻居决定，在初始阶段，标签传播算法对于每一个节点都会初始化一个唯一标签，每一次迭代都会根据与自己相连的节点所属的标签改变自己的标签，更改的原则是选择与其相连的节点中所属标签最多的社区标签为自己的社区标签，随着社区标签不断传播，最终连接紧密的节点将有共同的标签，每个节点都有一个标识其所属社团的标签，也就完成了社团划分。计算结果的高随机性，重复运行两次 LPA 的社团划分结果往往并不一致。

2）Louvain Modularity 算法适合庞大网络的社群发现，算法采用启发式方式从而能够克服传统 Modularity 类算法的局限。这类算法可以用于检测网络攻击，在大规模网络安全领域中进行快速社群发现，并以来预防网络攻击，也可以用于主题建模，如从 在线社交平台中提取主题，基于文档中共同出现的术语，作为主题建模过程的一部分。

图模型之深度学习：面向图数据的向量嵌入

图的嵌入学习是将机器或深度学习算法应用于图网络的重要前提。图嵌入，又称 Graph Embedding(GE，Network Embedding)，是一种将图数据（通常为高维稠密的矩阵）映射为低维稠密向量的过程，是将节点和关系进行数值化的重要方式，其思想在于把图中的节点或者边嵌入到一个低维的向量空间中，且节点或边在该低维空间的关系能比较完整地保留原图的结构信息，以解决图数据难以高效输入机器学习算法的问题。向量化后的节点，可以作为社区划分等后续工作的输入。

图形嵌入领域已经有了大量的研究，大体上分为三大类：基于因子分解的方法、基于随机游走的方法以及基于深度学习的方法。基于随机游走的嵌入学习先进行图的结构学习，再与属性特征融合进行下游任务学习，学习任务是割裂的，图神经网络的结构学习和下游任务是端对端的一个学习过程，比起割裂的学习更加高效，性能也更好。

基于因子分解的图嵌入

图分解（Graph Factorization）使用邻接矩阵的近似分解作为嵌入。LINE扩展了这种方法，并试图保持一阶和二阶近似。HOPE通过使用广义奇异值分解( SVD )分解相似性矩阵而不是邻接矩阵来扩展LINE以试图保持高阶邻近性。SDNE 使用自动编码器嵌入图形节点并捕捉高度非线性的依赖关系。

基于随机游走的图嵌入

做过自然语言处理的朋友都知道，word2vec 是一种常用的 word embedding 方法，其通过语料库中的句子序列来描述词与词的共现关系，进而学习到词语的向量表示，Graph Embedding 采用了类似 的的思想，使用图中节点与节点的共现关系来学习节点的向量表示，其首先在 graph 中随机游走生成顶点序列，构成训练集，然后采用 skip-gram 算法，训练出低维稠密向量来表示顶点。

GraphEmbedding类的算法本质上就是将低阶特征进行Embedding化，业界常用的有DeepWalk、Node2Vec(基于拓扑结构的)、LINE(加入属性信息的)、EGES、以及通过标签信息和随机性共同考虑去做的图剪辑。Perozzi等人在KDD 2014提出的DeepWalk模型是图嵌入学习的一个开山之作，该方法采用截断式随机游走方式把图中每个节点的局部拓扑结构转换成序列信息，并把Word2vec模型应用于阶段一产生的序列数据，学习序列中每个节点的embedding表示。图嵌入这种做法通常适用于无监督学习，其监督信号与最终目标通常不一致，只适用于多阶段训练。也没有充分发掘高阶的潜在关联关系。

基于图神经网络的图嵌入

图神经网络，又称(Graph Neural Networks,GNN)，指在图上利用图神经网络，通过端对端的方式，在一个学习过程中进行任务学习。图神经网络在学习的过程中，可以分为信息传递和信息聚合两个阶段，前者通过对邻居节点的Embedding进行消息传递，后者对邻居节点的Embedding进行聚合处理, 不同的GNN对应的聚合方式会有不同, 譬如取均值，加权求和，做基于长短期记忆(LSTM)变换处理。

根据消息的聚合方式不同，目前有图卷积网络GCN、GraphSage、图注意力机制GAT等常见的消息聚合方式。其中：图卷积网络(GCN)是对邻居的Embedding取均值然后与目标节点的Embedding进行加权求和；GraphSage在K-hop的随机采样的子图上对其邻居进行广义的聚合，然后与目标节点的Embedding进行拼接，其聚合方式包括取均值、池化操作以及LSTM计算等；图注意力机制(GAT)认为不同的邻居节点其重要性是不同的，在具体聚合的过程中根据注意力机制，首先计算目标节点和邻居节点的注意力系数，然后把注意力系数标准化后的值作为权重。

实际上，图嵌入的目标是发现高维图的低维向量表示是一件极具挑战的事情，与word2vec一样，如何选择一个质量高的嵌入表示，直接决定了下游任务的精度，一个好的图嵌入，需要从属性选择、以及维数等多个方面进行考虑。例如，在属性选择上，节点的”良好”向量表示应保留图的结构和单个节点之间的连接。在实际嵌入时很难找到表示的最佳维数，较高的维数可能会提高重建精度，但具有较高的时间和空间复杂性。较低的维度虽然时间、空间复杂度低，但无疑会损失很多图中原有的信息。

而就效果而言，图神经网络广泛应用于图的表征学习，与传统的图学习相比，既能学习图网络的拓扑结构，也能聚合邻居特征，从而能够有效的学习到图网络中的信息。

Original: https://blog.csdn.net/usermiszhao/article/details/122806492
Author: usermiszhao
Title: 图的概念与主要类型、图模型的应用场景