圖神經網絡是一類比較特殊的神經網絡，這裏的圖不同於我們卷積神經網絡裏面所使用到的圖像，而是指的是node和edge組成的具有拓撲結構的圖，這一類型的數據和應用我在平時的工作實踐中接觸得還是比較少的，正好就當做是學習了。
DGL是一個Python軟件包，專門用於在圖上進行深度學習，它構建在頂部現有的張量DL框架（例如Pytorch，MXNet）並簡化了基於圖的神經網絡的實現。
這裏DGL的安裝也是很簡單的，具體的安裝方案可以參考這裏。
windows下的安裝命令如下：
pip install dgl
整體的安裝是很簡單的。
本文主要是實踐DGL官網的教程【扎卡里的空手道俱樂部問題】。 空手道俱樂部是一個社交網絡，由34名成員組成，並記錄俱樂部外部互動的成員之間的成對鏈接。 俱樂部隨後分爲兩個社區，由教員（節點0）和俱樂部主席（節點33）領導。 網絡的可視化如下，其顏色指示社區：
該教程的任務是預測給定社交網絡本身每個成員傾向於加入哪一側（0或33）。
Step 1: Creating a graph in DGL
首先初始化創建圖，代碼實現如下所示:
def build_karate_club_graph():
'''
所有78條邊都存儲在兩個numpy數組中, 一個用於源端點而另一個用於目標端點
'''
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])
#邊緣在DGL中是有方向的； 使它們雙向
u = np.concatenate([src, dst])
v = np.concatenate([dst, src])
#構建圖
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())
結果如下所示：
接下來基於networkx來對圖進行可視化，代碼實現如下所示：
#通過將其轉換爲networkx圖來可視化該圖
nx_G = G.to_networkx().to_undirected()
pos = nx.kamada_kawai_layout(nx_G)
nx.draw(nx_G, pos, with_labels=True, node_color=[[.7, .7, .7]])
plt.savefig('graph.png')
結果如下所示：
這裏基於networkx繪製的是無向圖。
Step 2: Assign features to nodes or edges
圖神經網絡將特徵與節點和邊關聯以進行訓練。 對於我們的分類示例，由於沒有輸入功能，因此我們爲每個節點分配了可學習的嵌入向量。代碼實現如下所示：
embed = nn.Embedding(34, 5) # 34 nodes with embedding dim equal to 5
G.ndata['feat'] = embed.weight
print(G.ndata['feat'][2])
print(G.ndata['feat'][[10, 11]])
結果如下所示：
Step 3: Define a Graph Convolutional Network (GCN)
要執行節點分類，請使用由Kipf和Welling開發的圖卷積網絡（GCN）。 這是GCN框架的最簡單定義。 我們建議您閱讀原始文章以獲取更多詳細信息。
如下所示：
定義一個包含兩個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
#初始化網絡實例
net = GCN(5, 5, 2)
print('net: ', net)
結果如下所示：
Step 4: Data preparation and initialization
我們使用可學習的嵌入來初始化節點特徵。 由於這是半監督設置，因此僅爲教練（節點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: Train then visualize
訓練循環與其他PyTorch模型完全相同。 我們（1）創建一個優化器，（2）將輸入輸入模型，（3）計算損失，（4）使用自動分級優化模型。
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()))
結果如下所示：
這是一個很有趣的示例，因此甚至沒有驗證或測試集。 相反，由於模型爲每個節點生成大小爲2的輸出特徵，因此我們可以通過在2D空間中繪製輸出特徵來可視化。 以下代碼使訓練過程從最初的猜測（根本沒有對節點進行正確分類）到最終的結果（使節點線性可分離）動畫化。
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)
plt.savefig('0.png')
結果如下所示：
以下動畫顯示了經過一系列訓練後，模型如何正確預測社區。
今天是圖神經網絡的初步實踐，後面有時間會繼續學習。
完整代碼如下所示：
#!usr/bin/env python
#encoding:utf-8
from __future__ import division
"""
__Author__:沂水寒城
DGL概覽:
DGL是一個Python軟件包，專門用於在圖上進行深度學習，它構建在頂部現有的張量DL框架
（例如Pytorch，MXNet）並簡化了基於圖的神經網絡的實現。
"""
import dgl
import numpy as np
import networkx as nx
import torch
import torch.nn as nn
import torch.nn.functional as F
from dgl.nn.pytorch import GraphConv
import itertools
import matplotlib.animation as animation
import matplotlib.pyplot as plt
#Step 1: Creating a graph in DGL
def build_karate_club_graph():
'''
所有78條邊都存儲在兩個numpy數組中, 一個用於源端點而另一個用於目標端點
'''
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])
#邊緣在DGL中是有方向的； 使它們雙向
u = np.concatenate([src, dst])
v = np.concatenate([dst, src])
#構建圖
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())
#通過將其轉換爲networkx圖來可視化該圖
nx_G = G.to_networkx().to_undirected()
pos = nx.kamada_kawai_layout(nx_G)
nx.draw(nx_G, pos, with_labels=True, node_color=[[.7, .7, .7]])
plt.savefig('graph.png')
# Step 2: Assign features to nodes or edges
embed = nn.Embedding(34, 5) # 34 nodes with embedding dim equal to 5
G.ndata['feat'] = embed.weight
print(G.ndata['feat'][2])
print(G.ndata['feat'][[10, 11]])
# Step 3: Define a Graph Convolutional Network (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
#初始化網絡實例
net = GCN(5, 5, 2)
print('net: ', net)
# Step 4: Data preparation and initialization
inputs = embed.weight
labeled_nodes = torch.tensor([0, 33]) #
labels = torch.tensor([0, 1])
# Step 5: Train then visualize
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()))
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)
plt.savefig('0.png')
ani = animation.FuncAnimation(fig, draw, frames=len(all_logits), interval=200)
plt.savefig('1.png')