DGL 0.5 Tutorials : Basics : ひとめでわかる DGL (翻訳/解説)

翻訳 : (株)クラスキャットセールスインフォメーション
作成日時 : 09/05/2020 (0.5.1)

* 本ページは、DGL の以下のドキュメントを翻訳した上で適宜、補足説明したものです：

DGL at a Glance

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

Tutorials : Basics : ひとめでわかる DGL

DGL は既存の tensor DL フレームワーク (e.g. PyTorch, MXNet) の上に構築されてグラフベースのニューラルネットワークの実装を単純化する、グラフ上の深層学習専用の Python パッケージです。

このチュートリアルのゴールは :

DGL がどのようにグラフ上の計算を可能にするか高位から理解する。
グラフのノードを分類するために DGL で単純なグラフニューラルネットワークを訓練する。

このチュートリアルの最後に、どのように DGL が動作するかの簡潔なフィーリングを貴方が得ることを望みます。

チュートリアル問題説明

このチュートリアルは「Zachary の空手クラブ」問題に基づいています。空手クラブは 34 メンバーを含む (クラブ外で相互作用する) メンバー間の対の (= pairwise) リンクを文書化するソーシャルネットワークです。クラブはインストラクター (node 0) とクラブ会長 (node 33) により導かれる 2 つのコミュニティに後で分かれます。ネットワークはコミュニティを示すカラーで次のように可視化されます :

タスクはソーシャルネットワーク自身が与えられたとき各メンバーがどちらの側 (0 or 33) に参加する傾向があるかを予測することです。

Step 1: DGL でグラフを作成する

Zachary の空手クラブのためにグラフを次のように作成します :

import dgl
import numpy as np

def build_karate_club_graph():
    # All 78 edges are stored in two numpy arrays. One for source endpoints
    # while the other for destination endpoints.
    src = np.array([1, 2, 2, 3, 3, 3, 4, 5, 6, 6, 6, 7, 7, 7, 7, 8, 8, 9, 10, 10,
        10, 11, 12, 12, 13, 13, 13, 13, 16, 16, 17, 17, 19, 19, 21, 21,
        25, 25, 27, 27, 27, 28, 29, 29, 30, 30, 31, 31, 31, 31, 32, 32,
        32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33,
        33, 33, 33, 33, 33, 33, 33, 33, 33, 33])
    dst = np.array([0, 0, 1, 0, 1, 2, 0, 0, 0, 4, 5, 0, 1, 2, 3, 0, 2, 2, 0, 4,
        5, 0, 0, 3, 0, 1, 2, 3, 5, 6, 0, 1, 0, 1, 0, 1, 23, 24, 2, 23,
        24, 2, 23, 26, 1, 8, 0, 24, 25, 28, 2, 8, 14, 15, 18, 20, 22, 23,
        29, 30, 31, 8, 9, 13, 14, 15, 18, 19, 20, 22, 23, 26, 27, 28, 29, 30,
        31, 32])
    # Edges are directional in DGL; Make them bi-directional.
    u = np.concatenate([src, dst])
    v = np.concatenate([dst, src])
    # Construct a DGLGraph
    return dgl.DGLGraph((u, v))

新しく構築されたグラフのノードとエッジの数をプリントアウトできます :

G = build_karate_club_graph()
print('We have %d nodes.' % G.number_of_nodes())
print('We have %d edges.' % G.number_of_edges())

/home/ubuntu/prod-doc/readthedocs.org/user_builds/dgl/checkouts/0.5.x/python/dgl/base.py:45: DGLWarning: Recommend creating graphs by `dgl.graph(data)` instead of `dgl.DGLGraph(data)`.
  return warnings.warn(message, category=category, stacklevel=1)
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: 特徴をノードかエッジに割り当てる

グラフニューラルネットワークは訓練のために特徴をノードとエッジに関連付けます。私達の分類例のためには、入力特徴はありませんので、各ノードを学習可能な埋め込みベクトルとして割当てます。

# In DGL, you can add features for all nodes at once, using a feature tensor that
# batches node features along the first dimension. The code below adds the learnable
# embeddings for all nodes:

import torch
import torch.nn as nn
import torch.nn.functional as F

embed = nn.Embedding(34, 5)  # 34 nodes with embedding dim equal to 5
G.ndata['feat'] = embed.weight

検証するためにノード特徴をプリントアウトすることができます :

# print out node 2's input feature
print(G.ndata['feat'][2])

# print out node 10 and 11's input features
print(G.ndata['feat'][[10, 11]])

tensor([ 0.1693,  1.1574, -1.6917, -0.6862, -1.4258], grad_fn=<SelectBackward>)
tensor([[-1.6451, -1.8674, -0.9091,  0.4529, -1.3746],
        [ 0.1275, -1.8345,  0.5097, -0.2168, -1.2748]],
       grad_fn=<IndexBackward>)

Step 3: グラフ畳み込みネットワーク (GCN) を定義する

ノード分類を遂行するために、Kipf と Welling により開発されたグラフ畳み込みネットワーク (GCN) を利用します。ここに GCN フレームワークの最も単純な定義があります。より詳細のためには元のペーパーを読むことを勧めます。

層 $l$ で、各ノード $v_i^l$ は特徴ベクトル $h_i^l$ を carry します。
GCN の各層は $u_i^{l}$ からの特徴を $v_i^{l+1}$ における次の層の表現へと集めようとします、ここで $u_i$ は $v$ への近傍ノードです。これにある非線形を伴うアフィン変換が続きます。

GCN の上の定義はメッセージパッシング・パラダイムに適合します : 各ノードは近傍ノードから送られた情報でそれ自身の特徴を更新します。グラフィカルなデモは下に表示されます。

DGL では、dgl.<backend>.nn サブパッケージの下でポピュラーなグラフ・ニューラルネットワーク層の実装を提供します。GraphConv モジュールは一つのグラフ畳込み層を実装しています。

from dgl.nn.pytorch import GraphConv

2 つの GCN 層を含むより深い GCN モデルを定義します :

class GCN(nn.Module):
    def __init__(self, in_feats, hidden_size, num_classes):
        super(GCN, self).__init__()
        self.conv1 = GraphConv(in_feats, hidden_size)
        self.conv2 = GraphConv(hidden_size, num_classes)

    def forward(self, g, inputs):
        h = self.conv1(g, inputs)
        h = torch.relu(h)
        h = self.conv2(g, h)
        return h

# The first layer transforms input features of size of 5 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(5, 5, 2)

Step 4: データ準備と初期化

ノード特徴を初期化するために学習可能な埋め込みを使用します。これは半教師あり設定ですから、インストラクター (ノード 0) とクラブ会長 (ノード 33) だけがラベルを割り当てられます。実装は次のように利用可能です。

inputs = embed.weight
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 を使用します。

import itertools

optimizer = torch.optim.Adam(itertools.chain(net.parameters(), embed.parameters()), lr=0.01)
all_logits = []
for epoch in range(50):
    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: 0.9058
Epoch 1 | Loss: 0.8522
Epoch 2 | Loss: 0.8050
Epoch 3 | Loss: 0.7663
Epoch 4 | Loss: 0.7339
Epoch 5 | Loss: 0.7067
Epoch 6 | Loss: 0.6846
Epoch 7 | Loss: 0.6649
Epoch 8 | Loss: 0.6490
Epoch 9 | Loss: 0.6344
Epoch 10 | Loss: 0.6204
Epoch 11 | Loss: 0.6069
Epoch 12 | Loss: 0.5939
Epoch 13 | Loss: 0.5808
Epoch 14 | Loss: 0.5680
Epoch 15 | Loss: 0.5560
Epoch 16 | Loss: 0.5426
Epoch 17 | Loss: 0.5277
Epoch 18 | Loss: 0.5124
Epoch 19 | Loss: 0.4966
Epoch 20 | Loss: 0.4802
Epoch 21 | Loss: 0.4631
Epoch 22 | Loss: 0.4457
Epoch 23 | Loss: 0.4279
Epoch 24 | Loss: 0.4094
Epoch 25 | Loss: 0.3907
Epoch 26 | Loss: 0.3717
Epoch 27 | Loss: 0.3526
Epoch 28 | Loss: 0.3334
Epoch 29 | Loss: 0.3144
Epoch 30 | Loss: 0.2956
Epoch 31 | Loss: 0.2770
Epoch 32 | Loss: 0.2585
Epoch 33 | Loss: 0.2402
Epoch 34 | Loss: 0.2226
Epoch 35 | Loss: 0.2057
Epoch 36 | Loss: 0.1894
Epoch 37 | Loss: 0.1737
Epoch 38 | Loss: 0.1587
Epoch 39 | Loss: 0.1446
Epoch 40 | Loss: 0.1313
Epoch 41 | Loss: 0.1187
Epoch 42 | Loss: 0.1066
Epoch 43 | Loss: 0.0954
Epoch 44 | Loss: 0.0852
Epoch 45 | Loss: 0.0759
Epoch 46 | Loss: 0.0675
Epoch 47 | Loss: 0.0600
Epoch 48 | Loss: 0.0533
Epoch 49 | Loss: 0.0473

これは寧ろ 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)

以上

2020年9月
月	火	水	木	金	土	日
	1	2	3	4	5	6
7	8	9	10	11	12	13
14	15	16	17	18	19	20
21	22	23	24	25	26	27
28	29	30