使用這些基本 REST API 最佳實踐構建出色的 API
消息(嵌入)通過多個GNN層在圖中的節點之間傳遞。每個節點聚合來自其鄰居的消息以更新其表示。這個過程跨層重復，允許節點獲得編碼有關圖的更豐富信息的表示。gnn的一主要變體有GraphSAGE[2]、Graph Convolution Network[3]等。
圖注意力網絡(GAT)[1]是一類經典的GNN，很適合用于上手GNN模型。它主要的改進是消息傳遞的方式。他們引入了一種可學習的注意力機制，通過在每個源節點和目標節點之間分配權重，使節點能夠在聚合來自本地鄰居的消息時決定哪個鄰居節點更重要，而不是以相同的權重聚合來自所有鄰居的信息。
圖注意力網絡在節點分類、鏈接預測和圖分類等任務上優于許多其他GNN模型。他們在幾個基準圖數據集上也展示了最先進的性能。
在這篇文章中，我們將介紹原始《Graph Attention Networks》（by Veli?kovi? ）論文的關鍵部分，并使用PyTorch實現論文中提出的概念，這樣以更好地掌握GAT方法。
然后將論文的方法與現有的一些方法進行比較，并指出它們之間的一般異同，這是論文的常用格式，就不多介紹了。
本節是本文的主要部分，對圖注意力網絡的體系結構進行了詳細的闡述。為了進一步解釋，假設所提出的架構在一個有N個節點的圖上執行(V = {V′};i=1，…，N)，每個節點用向量h ^ (F個元素)表示，節點之間存在任意邊。
作者首先描述了單個圖注意力層的特征，以及它是如何運作的（因為它是圖注意力網絡的基本構建塊）。一般來說，單個GAT層應該將具有給定節點嵌入(表示)的圖作為輸入，將信息傳播到本地鄰居節點，并輸出更新后的節點表示。
如上所述，ga層的所有輸入節點特征向量(h′)都是線性變換的(即乘以一個權重矩陣W)，在PyTorch中，通常是這樣做的:
import torch
from torch import nn
# in_features -> F and out_feature -> F'
in_features = ...
out_feature = ...
# instanciate the learnable weight matrix W (FxF')
W = nn.Parameter(torch.empty(size=(in_features, out_feature)))
# Initialize the weight matrix W
nn.init.xavier_normal_(W)
# multiply W and h (h is input features of all the nodes -> NxF matrix)
h_transformed = torch.mm(h, W)獲得了輸入節點特征(嵌入)的轉換版本后我們先跳到最后查看和理解GAT層的最終目標是什么。
如論文所述，在圖注意層的最后，對于每個節點i，我們需要從其鄰域獲得一個新的特征向量，該特征向量更具有結構和上下文感知性。
這是通過計算相鄰節點特征的加權和，然后是非線性激活函數σ來完成的。根據Graph ML文獻，這個加權和在一般GNN層操作中也被稱為“聚合”步驟。
論文的這些權重α′?∈[0,1]是通過一種關注機制來學習和計算的，該機制表示在消息傳遞和聚合過程中節點i的鄰居j特征的重要性。
每一對節點i和它的鄰居j計算這些注意權值α′?的計算方法如下
其中e ^?是注意力得分，在應用Softmax函數后，有權重都會在[0,1]區間內，并且和為1。現在通過注意函數a(…)計算每個節點i和它的鄰居j∈N′之間的注意分數e′?，如下所示:
上圖中的||表示兩個轉換后的節點嵌入的連接，a是大小為2 * F ‘(轉換后嵌入大小的兩倍)的可學習參數(即注意力參數)向量。而(a1)是向量a的轉置，導致整個表達式a1[Wh′|| Wh?]是“a”與轉換后的嵌入的連接之間的點(內)積。
整個操作說明如下:
在PyTorch中，我們采用了一種稍微不同的方法。因為計算所有節點對之間的e′?然后只選擇代表節點之間現有邊的那些是更有效的。來計算所有的e′?
# instanciate the learnable attention parameter vector a
a = nn.Parameter(torch.empty(size=(2 * out_feature, 1)))
# Initialize the parameter vector a
nn.init.xavier_normal_(a)
# we obtained h_transformed in the previous code snippet
# calculating the dot product of all node embeddings
# and first half the attention vector parameters (corresponding to neighbor messages)
source_scores = torch.matmul(h_transformed, self.a[:out_feature, :])
# calculating the dot product of all node embeddings
# and second half the attention vector parameters (corresponding to target node)
target_scores = torch.matmul(h_transformed, self.a[out_feature:, :])
# broadcast add
e = source_scores + target_scores.T
e = self.leakyrelu(e)代碼片段的最后一部分(# broadcast add)將所有一對一的源和目標分數相加，得到一個包含所有e′?分數的NxN矩陣。(下圖所示)
到目前為止，我們假設圖是完全連接的，我們計算的是所有可能的節點對之間的注意力得分。但是其實大部分情況下圖不可能是完全連接的，所以為了解決這個問題，在將LeakyReLU激活應用于注意力分數之后，注意力分數基于圖中現有的邊被屏蔽，這意味著我們只保留與現有邊對應的分數。
它可以通過給不存在邊的節點之間的分數矩陣中的元素分配一個大的負分數(近似于-∞)來完成，這樣它們對應的注意力權重在softmax之后變為零（還記得我們以前發的注意力掩碼么，就是一樣的道理）。
這里的注意力掩碼是通過使用圖的鄰接矩陣來實現的。鄰接矩陣是一個NxN矩陣，如果節點i和j之間存在一條邊，則在第i行和第j列處為1，在其他地方為0。因此，我們通過將鄰接矩陣的零元素賦值為-∞并在其他地方賦值為0來創建掩碼。然后將掩碼添加到分數矩陣中。然后在它的行上應用softmax函數。
connectivity_mask = -9e16 * torch.ones_like(e)
# adj_mat is the N by N adjacency matrix
e = torch.where(adj_mat > 0, e, connectivity_mask) # masked attention scores
# attention coefficients are computed as a softmax over the rows
# for each column j in the attention score matrix e
attention = F.softmax(e, dim=-1)最后，根據論文描述，在獲得注意力分數并將其與現有的邊進行掩碼遮蔽后，通過對分數矩陣的行執行softmax，得到注意力權重α1?。
我們通過一個完整的可視化圖過程如下：
最后就是計算節點嵌入的加權和:
# final node embeddings are computed as a weighted average of the features of its neighbors
h_prime = torch.matmul(attention, h_transformed)以上一個一個注意力頭的工作流程和原理，論文還引入了多頭的概念，其中所有操作都是通過多個并行的操作流來完成的。
多頭注意力和聚合過程如下圖所示:
節點1在其鄰域中的多頭注意力(K = 3個頭)，不同的箭頭樣式和顏色表示獨立的注意力計算。將來自每個頭部的聚合特征連接或平均以獲得h ‘。
為了以更簡潔的模塊化形式(作為PyTorch模塊)封裝實現并合并多頭注意力的功能，整個Graph關注層的實現如下:
import torch
from torch import nn
import torch.nn.functional as F
################################
### GAT LAYER DEFINITION ###
################################
class GraphAttentionLayer(nn.Module):
def __init__(self, in_features: int, out_features: int,
n_heads: int, concat: bool = False, dropout: float = 0.4,
leaky_relu_slope: float = 0.2):
super(GraphAttentionLayer, self).__init__()
self.n_heads = n_heads # Number of attention heads
self.concat = concat # wether to concatenate the final attention heads
self.dropout = dropout # Dropout rate
if concat: # concatenating the attention heads
self.out_features = out_features # Number of output features per node
assert out_features % n_heads == 0 # Ensure that out_features is a multiple of n_heads
self.n_hidden = out_features // n_heads
else: # averaging output over the attention heads (Used in the main paper)
self.n_hidden = out_features
# A shared linear transformation, parametrized by a weight matrix W is applied to every node
# Initialize the weight matrix W
self.W = nn.Parameter(torch.empty(size=(in_features, self.n_hidden * n_heads)))
# Initialize the attention weights a
self.a = nn.Parameter(torch.empty(size=(n_heads, 2 * self.n_hidden, 1)))
self.leakyrelu = nn.LeakyReLU(leaky_relu_slope) # LeakyReLU activation function
self.softmax = nn.Softmax(dim=1) # softmax activation function to the attention coefficients
self.reset_parameters() # Reset the parameters
def reset_parameters(self):
nn.init.xavier_normal_(self.W)
nn.init.xavier_normal_(self.a)
def _get_attention_scores(self, h_transformed: torch.Tensor):
source_scores = torch.matmul(h_transformed, self.a[:, :self.n_hidden, :])
target_scores = torch.matmul(h_transformed, self.a[:, self.n_hidden:, :])
# broadcast add
# (n_heads, n_nodes, 1) + (n_heads, 1, n_nodes) = (n_heads, n_nodes, n_nodes)
e = source_scores + target_scores.mT
return self.leakyrelu(e)
def forward(self, h: torch.Tensor, adj_mat: torch.Tensor):
n_nodes = h.shape[0]
# Apply linear transformation to node feature -> W h
# output shape (n_nodes, n_hidden * n_heads)
h_transformed = torch.mm(h, self.W)
h_transformed = F.dropout(h_transformed, self.dropout, training=self.training)
# splitting the heads by reshaping the tensor and putting heads dim first
# output shape (n_heads, n_nodes, n_hidden)
h_transformed = h_transformed.view(n_nodes, self.n_heads, self.n_hidden).permute(1, 0, 2)
# getting the attention scores
# output shape (n_heads, n_nodes, n_nodes)
e = self._get_attention_scores(h_transformed)
# Set the attention score for non-existent edges to -9e15 (MASKING NON-EXISTENT EDGES)
connectivity_mask = -9e16 * torch.ones_like(e)
e = torch.where(adj_mat > 0, e, connectivity_mask) # masked attention scores
# attention coefficients are computed as a softmax over the rows
# for each column j in the attention score matrix e
attention = F.softmax(e, dim=-1)
attention = F.dropout(attention, self.dropout, training=self.training)
# final node embeddings are computed as a weighted average of the features of its neighbors
h_prime = torch.matmul(attention, h_transformed)
# concatenating/averaging the attention heads
# output shape (n_nodes, out_features)
if self.concat:
h_prime = h_prime.permute(1, 0, 2).contiguous().view(n_nodes, self.out_features)
else:
h_prime = h_prime.mean(dim=0)
return h_prime最后將上面所有的代碼整合成一個完整的GAT模型：
class GAT(nn.Module):
def __init__(self,
in_features,
n_hidden,
n_heads,
num_classes,
concat=False,
dropout=0.4,
leaky_relu_slope=0.2):
super(GAT, self).__init__()
# Define the Graph Attention layers
self.gat1 = GraphAttentionLayer(
in_features=in_features, out_features=n_hidden, n_heads=n_heads,
concat=concat, dropout=dropout, leaky_relu_slope=leaky_relu_slope
)
self.gat2 = GraphAttentionLayer(
in_features=n_hidden, out_features=num_classes, n_heads=1,
concat=False, dropout=dropout, leaky_relu_slope=leaky_relu_slope
)
def forward(self, input_tensor: torch.Tensor , adj_mat: torch.Tensor):
# Apply the first Graph Attention layer
x = self.gat1(input_tensor, adj_mat)
x = F.elu(x) # Apply ELU activation function to the output of the first layer
# Apply the second Graph Attention layer
x = self.gat2(x, adj_mat)
return F.softmax(x, dim=1) # Apply softmax activation function作者對GATs和其他一些現有GNN方法/架構進行了比較：
在論文的第三部分中，作者描述了評估GAT的基準、數據集和任務。然后，他們提出了他們對模型的評估結果。
論文中用作基準的數據集分為兩種類型的任務，轉換和歸納。
歸納學習:這是一種監督學習任務，其中模型僅在一組標記的訓練樣例上進行訓練，并且在訓練過程中完全未觀察到的樣例上對訓練后的模型進行評估和測試。這是一種被稱為普通監督學習的學習類型。
傳導學習:在這種類型的任務中，所有的數據，包括訓練、驗證和測試實例，都在訓練期間使用。但是在每個階段，模型只訪問相應的標簽集。這意味著在訓練期間，模型只使用由訓練實例和標簽產生的損失進行訓練，但測試和驗證特征用于消息傳遞。這主要是因為示例中存在的結構和上下文信息。
論文使用四個基準數據集來評估GATs，其中三個對應于傳導學習，另一個用作歸納學習任務。
轉導學習數據集，即Cora、Citeseer和Pubmed (Sen et al.， 2008)數據集都是引文圖，其中節點是已發布的文檔，邊(連接)是它們之間的引用，節點特征是文檔的詞包表示的元素。
歸納學習數據集是一個蛋白質-蛋白質相互作用(PPI)數據集，其中包含不同人體組織的圖形(Zitnik & Leskovec, 2017)。數據集的詳細描述如下:
作者報告了四個基準測試的以下性能，顯示了GATs與現有GNN方法的可比結果。
通過閱讀這篇文章并試用代碼，希望你能夠對GATs的工作原理以及如何在實際場景中應用它們有一個扎實的理解。
本文的完整代碼在這里：
https://github.com/ebrahimpichka/GAT-pt
[1] — Graph Attention Networks (2017), Petar Veli?kovi?, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Liò, Yoshua Bengio. arXiv:1710.10903v3
[2] — Inductive Representation Learning on Large Graphs (2017), William L. Hamilton, Rex Ying, Jure Leskovec. arXiv:1706.02216v4
[3] — Semi-Supervised Classification with Graph Convolutional Networks (2016), Thomas N. Kipf, Max Welling. arXiv:1609.02907v4
文章轉自微信公眾號@算法進階