[Red neuronal gráfica] PyTorch simplemente implementa un GCN

Pytorch viene con una biblioteca de redes neuronales gráficas PyG, que es similar a construir una red neuronal convolucional. A diferencia de la red neuronal convolucional, que solo necesita refactorizar las funciones __init__() y forward() , PyTorch debe refactorizar adicionalmente las funciones propagate() y message() .

1. Construcción del entorno

        ①Instale el paquete torch_geometric.

pip install torch_geometric

        ②Importar bibliotecas relacionadas

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

2. Arquitectura de aprendizaje de grafos PyG

        Método de construcción: primero herede la clase MessagePassing, luego reescriba el constructor y los siguientes tres métodos:

message()      #构建消息传递
aggregate()    #将消息聚合到目标节点
update()       #更新消息节点

        1. Constructor

def __init__(self, aggr: Optional[str] = "add",
             flow: str = "source_to_target", node_dim: int = -2,
             decomposed_layers: int = 1):

parámetro	contenido
agregado	La forma de agregación de mensajes, métodos comunes: add , mean , min , max
fluir	La dirección de propagación del mensaje, source_to_target , desde el nodo de origen hasta el nodo de destino                              target_to_source : del nodo de destino al nodo de origen
nodo_dim	dimensiones de la comunicacion

        2. función de propagación

                Esta función es la función de inicio de la difusión del mensaje.Después de llamar a esta función, se ejecutará en secuencia: mensaje , agregado , actualización para completar la entrega del mensaje, agregación y actualización .

                La función se declara de la siguiente manera:

propagate(self, edge_index: Adj, size: Size = None, **kwargs)

parámetro	ilustrar
índice_de_borde	índice de borde
tamaño	El tamaño de la matriz de adyacencia, si es Ninguno, significa una matriz cuadrada
**cuartos	parámetros adicionales

        3. función de mensaje

                Utilizado para construir mensajes de nodo, el tensor pasado para propagar se puede asignar al nodo central y a los nodos vecinos, solo agregue _i (nodo central) o _j (nodo vecino) después del nombre de variable correspondiente .

self.propagate(edge_index, x=x):
    pass

def message(self, x_i, x_j, edge_index_i):
    pass

x_i	Una matriz compuesta de vectores propios compuestos de nodos centrales
x_j	Una matriz de vectores propios compuesta de nodos vecinos
edge_index_i	El índice del nodo central.

        4. función agregada

                Función de agregación de mensajes, utilizada para agregar mensajes de vecinos. Los métodos comunes incluyen add, sum, mean y max, que se pueden configurar mediante el parámetro aggr en super().__init__()

        5. función de actualización

                Mensajes para actualizar nodos

3. Red convolucional de gráficos GCN

        El principio de la red GCN se puede ver: Graph Convolutional Neural Network--GCN

        Tenga en cuenta que torch_scatter no se puede cargar usando pip install, vea  la instalación de torch_scatter

        1. Cargue el conjunto de datos

from torch_geometric.datasets import Planetoid

dataset = Planetoid(root='Cora', name='Cora')

                El conjunto de datos de Cora es una recopilación de datos de gráfico (Graph) construida sobre la base de la relación de citación mutua entre artículos científicos. Hay 7 categorías de artículos, 2708 artículos (2708 nodos) y 10556 bordes.

        2. Definir la capa GCN

class GCNConv(MessagePassing):
    def __init__(self, in_channels, out_channels, add_self_loops=True, bias=True):
        super(GCNConv, self).__init__()
        self.add_self_loops = add_self_loops
        self.edge_index = None
        self.linear = pyg_nn.dense.linear.Linear(in_channels, out_channels, weight_initializer='glorot')
        
        
        if bias:
            self.bias = nn.Parameter(torch.Tensor(out_channels, 1))
            self.bias = pyg_nn.inits.glorot(self.bias)
        else:
            self.register_parameter('bias', None)
    
    # 1.消息传递
    def message(self, x, edge_index):
        # 1.对所有节点进行新的空间映射
        x = self.linear(x) # [num_nodes, feature_size]
        # 2.添加偏置
        if self.bias != None:
            x += self.bias.flatten()
        # 3.返回source、target信息，对应边的起点和终点
        row, col = edge_index # [E]
        # 4.获得度矩阵
        deg = degree(col, x.shape[0], x.dtype) # [num_nodes]
        # 5.度矩阵归一化
        deg_inv_sqrt = deg.pow(-0.5) # [num_nodes]
        # 6.计算sqrt(deg(i)) * sqrt(deg(j))
        norm = deg_inv_sqrt[row] * deg_inv_sqrt[col] # [num_nodes]
        # 7.返回所有边的映射
        x_j = x[row] # [E, feature_size]
        # 8.计算归一化后的节点特征
        x_j = norm.view(-1, 1) * x_j # [E, feature_size]
        
        return x_j
    
    # 2.消息聚合
    def aggregate(self, x_j, edge_index):
        # 1.返回source、target信息，对应边的起点和终点
        row, col = edge_index # [E]
        # 2.聚合邻居特征
        aggr_out = scatter(x_j, row, dim=0, reduce='sum') # [num_nodes, feature_size]
        
        return aggr_out
    
    # 3.节点更新
    def update(self, aggr_out):
        # 对于GCN没有这个阶段，所以直接返回
        return aggr_out
    
    def forward(self, x, edge_index):
        # 2.添加自环信息，考虑自身信息
        if self.add_self_loops:
            edge_index, _ = add_self_loops(edge_index, num_nodes=x.shape[0]) # [2, E]
        
        return self.propagate(edge_index, x=x)

        3. Definir la red GCN

class GCN(nn.Module):
    def __init__(self, num_node_features, num_classes):
        super(GCN, self).__init__()
        self.conv1 = GCNConv(num_node_features, 16)
        self.conv2 = GCNConv(16, num_classes)
        
    def forward(self, data):
        x, edge_index = data.x, data.edge_index
        
        x = self.conv1(x, edge_index)
        x = F.relu(x)
        x = F.dropout(x, training=self.training)
        x = self.conv2(x, edge_index)
        
        return F.log_softmax(x, dim=1)

        4. Modelo de llamada

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的一张图

# 4.定义模型
model = GCN(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))