PyTorch : DGL Tutorials : Basics : ひとめでわかる DGL (翻訳/解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 06/02/2019
* 本ページは、DGL のドキュメント DGL at a Glance を翻訳した上で適宜、補足説明したものです：
* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。
DGL Tutorials : Basics : ひとめでわかる DGL
DGL は既存の tensor DL フレームワーク (e.g. PyTorch, MXNet) の上に構築されたグラフ上の深層学習専用の Python パッケージです、そしてグラフニューラルネットワークの実装を単純化します。
このチュートリアルのゴールは :
- DGL がどのように高位からのグラフ上の計算を可能にするか理解する。
- グラフのノードを分類するために DGL で単純なグラフニューラルネットワークを訓練する。
このチュートリアルの最後に、どのように DGL が動作するかの簡潔なフィーリングを貴方が得ることを望みます。
Step 0: 問題記述
「Zachary の空手クラブ」問題から始めます。空手クラブは 34 メンバーを捉えて (クラブ外で相互作用する) メンバー間の対のリンクを文書化するソーシャルネットワークです。クラブは後でインストラクター (node 0) とクラブ会長 (node 33) により導かれる 2 つのコミュニティに分かれます。ネットワークはコミュニティを示すカラーで次のように可視化されます :
このタスクはソーシャルネットワーク自身が与えられたとき各メンバーがどちらの側 (0 or 33) に参加する傾向があるかを予測することです。
Step 1: DGL でグラフを作成する
Zachary の空手クラブのためのグラフの作成は次のようなものです :
import dgl
def build_karate_club_graph():
g = dgl.DGLGraph()
# add 34 nodes into the graph; nodes are labeled from 0~33
g.add_nodes(34)
# all 78 edges as a list of tuples
edge_list = [(1, 0), (2, 0), (2, 1), (3, 0), (3, 1), (3, 2),
(4, 0), (5, 0), (6, 0), (6, 4), (6, 5), (7, 0), (7, 1),
(7, 2), (7, 3), (8, 0), (8, 2), (9, 2), (10, 0), (10, 4),
(10, 5), (11, 0), (12, 0), (12, 3), (13, 0), (13, 1), (13, 2),
(13, 3), (16, 5), (16, 6), (17, 0), (17, 1), (19, 0), (19, 1),
(21, 0), (21, 1), (25, 23), (25, 24), (27, 2), (27, 23),
(27, 24), (28, 2), (29, 23), (29, 26), (30, 1), (30, 8),
(31, 0), (31, 24), (31, 25), (31, 28), (32, 2), (32, 8),
(32, 14), (32, 15), (32, 18), (32, 20), (32, 22), (32, 23),
(32, 29), (32, 30), (32, 31), (33, 8), (33, 9), (33, 13),
(33, 14), (33, 15), (33, 18), (33, 19), (33, 20), (33, 22),
(33, 23), (33, 26), (33, 27), (33, 28), (33, 29), (33, 30),
(33, 31), (33, 32)]
# add edges two lists of nodes: src and dst
src, dst = tuple(zip(*edge_list))
g.add_edges(src, dst)
# edges are directional in DGL; make them bi-directional
g.add_edges(dst, src)
return g
新たに構築されたグラフのノードとエッジの数を出力表示できます :
G = build_karate_club_graph()
print('We have %d nodes.' % G.number_of_nodes())
print('We have %d edges.' % G.number_of_edges())
We have 34 nodes. We have 156 edges.
それを networkx グラフに変換することによりグラフを可視化することもできます :
import networkx as nx # Since the actual graph is undirected, we convert it for visualization # purpose. nx_G = G.to_networkx().to_undirected() # Kamada-Kawaii layout usually looks pretty for arbitrary graphs pos = nx.kamada_kawai_layout(nx_G) nx.draw(nx_G, pos, with_labels=True, node_color=[[.7, .7, .7]])
Step 2: 特徴をノードまたはエッジに割り当てる
グラフニューラルネットワークは訓練のために特徴をノードとエッジに関連付けます。私達の分類例のために、各ノードの入力特徴を one-hot ベクトルとして割り当てます: ノード $v_i$ の特徴ベクトルは $[0,\ldots,1,\dots,0]$ で、そこでは $i^{th}$ 位置が 1 です。
DGL では、最初の次元に沿ったノード特徴をバッチ処理する特徴 tensor を使用して、総てのノードのために特徴を一度に追加できます。下のこのコードは総てのノードのために one-hot 特徴を追加します :
import torch G.ndata['feat'] = torch.eye(34)
検証するためにノード特徴を出力表示することができます :
# print out node 2's input feature print(G.nodes[2].data['feat']) # print out node 10 and 11's input features print(G.nodes[[10, 11]].data['feat'])
tensor([[0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]])
tensor([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]])
Step 3: グラフ畳み込みネットワーク (GCN) を定義する
ノード分類を遂行するために、Kipf と Welling により開発されたグラフ畳み込みネットワーク (GCN) を使用します。ここでは GCN フレームワークの最も単純な定義を提供しますが、より詳細のために読者に元のペーパーを読むことを勧めます。
- 層 $l$ で、各ノード $v_i^l$ は特徴ベクトル $h_i^l$ を運搬します。
- GCN の各層は $v_i^{l+1}$ における次の層の表現へと $u_i^{l}$ からの特徴を集めようとします、ここで $u_i$ は $v$ への近傍ノードです。これに非線形を伴うアフィン変換が続きます。
GCN の上の定義はメッセージパッシング・パラダイムに適合します : 各ノードは近傍ノードから送られた情報でそれ自身の特徴を更新します。グラフィカルなデモは下に表示されます。
さて、GCN 層が DGL で容易に実装できることを示します。
import torch.nn as nn
import torch.nn.functional as F
# Define the message & reduce function
# NOTE: we ignore the GCN's normalization constant c_ij for this tutorial.
def gcn_message(edges):
# The argument is a batch of edges.
# This computes a (batch of) message called 'msg' using the source node's feature 'h'.
return {'msg' : edges.src['h']}
def gcn_reduce(nodes):
# The argument is a batch of nodes.
# This computes the new 'h' features by summing received 'msg' in each node's mailbox.
return {'h' : torch.sum(nodes.mailbox['msg'], dim=1)}
# Define the GCNLayer module
class GCNLayer(nn.Module):
def __init__(self, in_feats, out_feats):
super(GCNLayer, self).__init__()
self.linear = nn.Linear(in_feats, out_feats)
def forward(self, g, inputs):
# g is the graph and the inputs is the input node features
# first set the node features
g.ndata['h'] = inputs
# trigger message passing on all edges
g.send(g.edges(), gcn_message)
# trigger aggregation at all nodes
g.recv(g.nodes(), gcn_reduce)
# get the result node features
h = g.ndata.pop('h')
# perform linear transformation
return self.linear(h)
一般に、ノードはメッセージ関数を通して計算された情報を送り、そして reduce 関数で入ってくる情報を集めます。
それから 2 つの GCN 層を含むより深い GCN モデルを定義します :
# Define a 2-layer GCN model
class GCN(nn.Module):
def __init__(self, in_feats, hidden_size, num_classes):
super(GCN, self).__init__()
self.gcn1 = GCNLayer(in_feats, hidden_size)
self.gcn2 = GCNLayer(hidden_size, num_classes)
def forward(self, g, inputs):
h = self.gcn1(g, inputs)
h = torch.relu(h)
h = self.gcn2(g, h)
return h
# The first layer transforms input features of size of 34 to a hidden size of 5.
# The second layer transforms the hidden layer and produces output features of
# size 2, corresponding to the two groups of the karate club.
net = GCN(34, 5, 2)
Step 4: データ準備と初期化
ノード特徴を初期化するために one-hot ベクトルを使用します。これは半教師あり設定ですから、インストラクター (ノード 0) とクラブ会長 (ノード 33) だけがラベルを割り当てられます。実装は次のように利用可能です。
inputs = torch.eye(34) labeled_nodes = torch.tensor([0, 33]) # only the instructor and the president nodes are labeled labels = torch.tensor([0, 1]) # their labels are different
Step 5: 訓練そして可視化
訓練ループは他の PyTorch モデルと正確に同じです。(1) optimizer を作成し、(2) 入力をモデルに供給し、(3) 損失を計算してそして (4) モデルを最適化するために autograd を使用します。
optimizer = torch.optim.Adam(net.parameters(), lr=0.01)
all_logits = []
for epoch in range(30):
logits = net(G, inputs)
# we save the logits for visualization later
all_logits.append(logits.detach())
logp = F.log_softmax(logits, 1)
# we only compute loss for labeled nodes
loss = F.nll_loss(logp[labeled_nodes], labels)
optimizer.zero_grad()
loss.backward()
optimizer.step()
print('Epoch %d | Loss: %.4f' % (epoch, loss.item()))
Epoch 0 | Loss: 1.4281 Epoch 1 | Loss: 1.0976 Epoch 2 | Loss: 0.8362 Epoch 3 | Loss: 0.6453 Epoch 4 | Loss: 0.5111 Epoch 5 | Loss: 0.4248 Epoch 6 | Loss: 0.3664 Epoch 7 | Loss: 0.3192 Epoch 8 | Loss: 0.2753 Epoch 9 | Loss: 0.2350 Epoch 10 | Loss: 0.1967 Epoch 11 | Loss: 0.1599 Epoch 12 | Loss: 0.1268 Epoch 13 | Loss: 0.1000 Epoch 14 | Loss: 0.0787 Epoch 15 | Loss: 0.0616 Epoch 16 | Loss: 0.0482 Epoch 17 | Loss: 0.0378 Epoch 18 | Loss: 0.0298 Epoch 19 | Loss: 0.0237 Epoch 20 | Loss: 0.0191 Epoch 21 | Loss: 0.0155 Epoch 22 | Loss: 0.0127 Epoch 23 | Loss: 0.0106 Epoch 24 | Loss: 0.0089 Epoch 25 | Loss: 0.0075 Epoch 26 | Loss: 0.0064 Epoch 27 | Loss: 0.0056 Epoch 28 | Loss: 0.0048 Epoch 29 | Loss: 0.0042
これはどちらかと言うと toy サンプルですので、検証やテストセットさえ持ちません。代わりに、モデルは各ノードに対してサイズ 2 の出力特徴を生成しますので、2D 空間で出力特徴をプロットすることにより可視化できます。次のコードは初期推測 (そこではノードは全く正しく分類されていません) から終わり (そこではノードは線形分離可能です) までの訓練過程をアニメーションにします。
import matplotlib.animation as animation
import matplotlib.pyplot as plt
def draw(i):
cls1color = '#00FFFF'
cls2color = '#FF00FF'
pos = {}
colors = []
for v in range(34):
pos[v] = all_logits[i][v].numpy()
cls = pos[v].argmax()
colors.append(cls1color if cls else cls2color)
ax.cla()
ax.axis('off')
ax.set_title('Epoch: %d' % i)
nx.draw_networkx(nx_G.to_undirected(), pos, node_color=colors,
with_labels=True, node_size=300, ax=ax)
fig = plt.figure(dpi=150)
fig.clf()
ax = fig.subplots()
draw(0) # draw the prediction of the first epoch
plt.close()
次のアニメーションは一連の訓練エポックの後モデルがどのように正しくコミュニティを予測するかを示します。
ani = animation.FuncAnimation(fig, draw, frames=len(all_logits), interval=200)
以上