怎么使用Pytorch+PyG實現MLP

這篇文章主要講解了“怎么使用Pytorch+PyG實現MLP”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“怎么使用Pytorch+PyG實現MLP”吧！

項目環境：

• 平臺：Windows10

• 語言環境：python3.7

• 編譯器：PyCharm

• PyTorch版本：1.11.0

• PyG版本：2.1.0

一、導入相關庫

本項目我們需要結合兩個庫，一個是Pytorch，因為還需要按照torch的網絡搭建模型進行書寫，第二個是PyG，因為在torch中并沒有關于圖網絡層的定義，所以需要torch_geometric這個庫來定義一些圖層。

import torch
import torch.nn.functional as F
import torch.nn as nn
import torch_geometric.nn as pyg_nn
from torch_geometric.datasets import Planetoid

二、加載Cora數據集

本文使用的數據集是比較經典的Cora數據集，它是一個根據科學論文之間相互引用關系而構建的Graph數據集合，論文分為7類，共2708篇。

• Genetic_Algorithms

• Neural_Networks

• Probabilistic_Methods

• Reinforcement_Learning

• Rule_Learning

• Theory

這個數據集是一個用于圖節點分類的任務，數據集中只有一張圖，這張圖中含有2708個節點，10556條邊，每個節點的特征維度為1433。

# 1.加載Cora數據集
dataset = Planetoid(root='./data/Cora', name='Cora')

三、定義MLP網絡

這里我們就不重點介紹MLP網絡了，相信大家能夠掌握基本原理，本文我們使用的是PyG定義網絡層，在PyG中已經定義好了MLP這個層，該層采用的就是感知機機制。

對于MLP的常用參數：

• channel_list：樣本輸入層、中間層、輸出層維度的列表

• in_channels：每個樣本的輸入維度，就是每個節點的特征維度

• hidden_channels：單層神經網絡中間的隱層大小

• out_channels：經過MLP后映射成的新的維度，就是經過MLP后每個節點的維度長度

• num_layers：感知機層數

• dropout：每個隱藏層的丟棄率，如果存在多層可以使用列表傳入

• act：激活函數，默認為relu

• bias：訓練一個偏置b

對于本文實現的 pyg_nn.MLP([num_node_features, 32, 64, 128]) 的含義就是定義一個三層的感知機網絡，按照 PyTorch 實現等價于如下代碼：

lin_1 = nn.Linear(num_node_features, 32)
lin_2 = nn.Linear(32, 64)
lin_3 = nn.Linear(64, 128)

對于 PyG 中實現起來較為簡單，以列表方式傳入所以隱層大小即可，第一個維度代表樣本的輸入特征維度，最后一個維度代表輸出的維度大小，中間維度代表隱層的大小，所以 len(channel_list) - 1 代表 MLP 的層數，這種方式是以傳入 channel_list 方式定義模型，還可以按照正常參數方式進行傳遞定義，代碼如下：

pyg_nn.MLP(in_channels=16,
		   hidden_channels=32,
		   out_channels=128,
		   num_layers=3)

網絡定義代碼如下：

# 2.定義MLP網絡
class MLP(nn.Module):
    def __init__(self, num_node_features, num_classes):
        super(MLP, self).__init__()
        self.lin_1 = pyg_nn.MLP([num_node_features, 32, 64, 128])
        self.lin_2 = pyg_nn.MLP([128, 64, 32, num_classes])
        
    def forward(self, data):
        x, edge_index = data.x, data.edge_index
        
        x = self.lin_1(x, edge_index)
        x = F.relu(x)
        x = F.dropout(x, training=self.training)
        x = self.lin_2(x, edge_index)
        
        return F.log_softmax(x, dim=1)

上面網絡我們定義了兩個MLP層，第一層的參數的輸入維度就是初始每個節點的特征維度，輸出維度是128。

第二個層的輸入維度為128，輸出維度為分類個數，因為我們需要對每個節點進行分類，最終加上softmax操作。

四、定義模型

下面就是定義了一些模型需要的參數，像學習率、迭代次數這些超參數，然后是模型的定義以及優化器及損失函數的定義，和pytorch定義網絡是一樣的。

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # 設備
epochs = 10 # 學習輪數
lr = 0.003 # 學習率
num_node_features = dataset.num_node_features # 每個節點的特征數
num_classes = dataset.num_classes # 每個節點的類別數
data = dataset[0].to(device) # Cora的一張圖

# 3.定義模型
model = MLP(num_node_features, num_classes).to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=lr) # 優化器
loss_function = nn.NLLLoss() # 損失函數

五、模型訓練

模型訓練部分也是和pytorch定義網絡一樣，因為都是需要經過前向傳播、反向傳播這些過程，對于損失、精度這些指標可以自己添加。

# 訓練模式
model.train()

for epoch in range(epochs):
    optimizer.zero_grad()
    pred = model(data)
    
    loss = loss_function(pred[data.train_mask], data.y[data.train_mask]) # 損失
    correct_count_train = pred.argmax(axis=1)[data.train_mask].eq(data.y[data.train_mask]).sum().item() # epoch正確分類數目
    acc_train = correct_count_train / data.train_mask.sum().item() # epoch訓練精度
    
    loss.backward()
    optimizer.step()
    
    if epoch % 20 == 0:
        print("【EPOCH: 】%s" % str(epoch + 1))
        print('訓練損失為：{:.4f}'.format(loss.item()), '訓練精度為：{:.4f}'.format(acc_train))

print('【Finished Training！】')

六、模型驗證

下面就是模型驗證階段，在訓練時我們是只使用了訓練集，測試的時候我們使用的是測試集，注意這和傳統網絡測試不太一樣，在圖像分類一些經典任務中，我們是把數據集分成了兩份，分別是訓練集、測試集，但是在Cora這個數據集中并沒有這樣，它區分訓練集還是測試集使用的是掩碼機制，就是定義了一個和節點長度相同緯度的數組，該數組的每個位置為True或者False，標記著是否使用該節點的數據進行訓練。

# 模型驗證
model.eval()
pred = model(data)

# 訓練集（使用了掩碼）
correct_count_train = pred.argmax(axis=1)[data.train_mask].eq(data.y[data.train_mask]).sum().item()
acc_train = correct_count_train / data.train_mask.sum().item()
loss_train = loss_function(pred[data.train_mask], data.y[data.train_mask]).item()

# 測試集
correct_count_test = pred.argmax(axis=1)[data.test_mask].eq(data.y[data.test_mask]).sum().item()
acc_test = correct_count_test / data.test_mask.sum().item()
loss_test = loss_function(pred[data.test_mask], data.y[data.test_mask]).item()

print('Train Accuracy: {:.4f}'.format(acc_train), 'Train Loss: {:.4f}'.format(loss_train))
print('Test  Accuracy: {:.4f}'.format(acc_test), 'Test  Loss: {:.4f}'.format(loss_test))

七、結果

【EPOCH: 】1
訓練損失為：1.9856 訓練精度為：0.1786
【EPOCH: 】21
訓練損失為：1.5419 訓練精度為：0.4643
【EPOCH: 】41
訓練損失為：1.1653 訓練精度為：0.6500
【EPOCH: 】61
訓練損失為：0.8062 訓練精度為：0.8071
【EPOCH: 】81
訓練損失為：0.5322 訓練精度為：0.9286
【EPOCH: 】101
訓練損失為：0.3487 訓練精度為：0.9714
【EPOCH: 】121
訓練損失為：0.2132 訓練精度為：0.9571
【EPOCH: 】141
訓練損失為：0.1043 訓練精度為：0.9929
【EPOCH: 】161
訓練損失為：0.0601 訓練精度為：1.0000
【EPOCH: 】181
訓練損失為：0.0420 訓練精度為：1.0000
【Finished Training！】

>>>Train Accuracy: 1.0000 Train Loss: 0.0092
>>>Test  Accuracy: 0.1800 Test  Loss: 1.9587

完整代碼

import torch
import torch.nn.functional as F
import torch.nn as nn
import torch_geometric.nn as pyg_nn
from torch_geometric.datasets import Planetoid

# 1.加載Cora數據集
dataset = Planetoid(root='./data/Cora', name='Cora')

# 2.定義MLP網絡
class MLP(nn.Module):
    def __init__(self, num_node_features, num_classes):
        super(MLP, self).__init__()
        self.lin_1 = pyg_nn.MLP([num_node_features, 32, 64, 128])
        self.lin_2 = pyg_nn.MLP([128, 64, 32, num_classes])
        
    def forward(self, data):
        x, edge_index = data.x, data.edge_index
        
        x = self.lin_1(x, edge_index)
        x = F.relu(x)
        x = F.dropout(x, training=self.training)
        x = self.lin_2(x, edge_index)
        
        return F.log_softmax(x, dim=1)

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # 設備
epochs = 200 # 學習輪數
lr = 0.0003 # 學習率
num_node_features = dataset.num_node_features # 每個節點的特征數
num_classes = dataset.num_classes # 每個節點的類別數
data = dataset[0].to(device) # Cora的一張圖

# 3.定義模型
model = MLP(num_node_features, num_classes).to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=lr) # 優化器
loss_function = nn.NLLLoss() # 損失函數

# 訓練模式
model.train()

for epoch in range(epochs):
    optimizer.zero_grad()
    pred = model(data)
    
    loss = loss_function(pred[data.train_mask], data.y[data.train_mask]) # 損失
    correct_count_train = pred.argmax(axis=1)[data.train_mask].eq(data.y[data.train_mask]).sum().item() # epoch正確分類數目
    acc_train = correct_count_train / data.train_mask.sum().item() # epoch訓練精度
    
    loss.backward()
    optimizer.step()
    
    if epoch % 20 == 0:
        print("【EPOCH: 】%s" % str(epoch + 1))
        print('訓練損失為：{:.4f}'.format(loss.item()), '訓練精度為：{:.4f}'.format(acc_train))

print('【Finished Training！】')

# 模型驗證
model.eval()
pred = model(data)

# 訓練集（使用了掩碼）
correct_count_train = pred.argmax(axis=1)[data.train_mask].eq(data.y[data.train_mask]).sum().item()
acc_train = correct_count_train / data.train_mask.sum().item()
loss_train = loss_function(pred[data.train_mask], data.y[data.train_mask]).item()

# 測試集
correct_count_test = pred.argmax(axis=1)[data.test_mask].eq(data.y[data.test_mask]).sum().item()
acc_test = correct_count_test / data.test_mask.sum().item()
loss_test = loss_function(pred[data.test_mask], data.y[data.test_mask]).item()

print('Train Accuracy: {:.4f}'.format(acc_train), 'Train Loss: {:.4f}'.format(loss_train))
print('Test  Accuracy: {:.4f}'.format(acc_test), 'Test  Loss: {:.4f}'.format(loss_test))

感謝各位的閱讀，以上就是“怎么使用Pytorch+PyG實現MLP”的內容了，經過本文的學習后，相信大家對怎么使用Pytorch+PyG實現MLP這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！