什么是图神经网络？

 import torch

    
 import torch.nn as nn
    
 import torch.optim as optim
    
 import torch.nn.functional as F
    
 import networkx as nx
    
 import numpy as np
    
 import matplotlib.pyplot as plt
    
  
    
 # 生成一个小的图数据集
    
 def create_graph():
    
     # 加载 Karate Club 图数据集，这是一个社交网络图，包含 34 个节点和 78 条边。
    
     G = nx.karate_club_graph()
    
     features = np.eye(G.number_of_nodes())
    
     # 为每个节点生成标签（0 或 1），表示节点属于哪个社区（Mr. Hi 或 Officer）。
    
     labels = np.array([G.nodes[i]['club'] == 'Mr. Hi' for i in range(G.number_of_nodes())], dtype=int)
    
     return G, features, labels
    
  
    
 # 定义原始GNN模型
    
 class GNN(nn.Module):
    
     def __init__(self, input_dim, hidden_dim, output_dim):
    
     super(GNN, self).__init__()
    
     self.fc1 = nn.Linear(input_dim, hidden_dim)
    
     self.fc2 = nn.Linear(hidden_dim, output_dim)
    
  
    
     def forward(self, x, adj):
    
     h = F.relu(self.fc1(x))
    
     # 使用邻接矩阵 adj 聚合邻居节点的信息。
    
     h = torch.matmul(adj, h)
    
     h = self.fc2(h)
    
     return F.log_softmax(h, dim=1)
    
  
    
 # 训练和测试函数
    
 def train(model, optimizer, features, labels, adj, train_mask, epochs=10):
    
     model.train()
    
     for epoch in range(epochs):
    
     optimizer.zero_grad()
    
     output = model(features, adj)
    
     # 计算负对数似然损失
    
     loss = F.nll_loss(output[train_mask], labels[train_mask])
    
     loss.backward()
    
     optimizer.step()
    
     print(f'Epoch: {epoch + 1}, Loss: {loss.item():.4f}')
    
  
    
 def test(model, features, labels, adj, mask):
    
     model.eval()
    
     with torch.no_grad():
    
     output = model(features, adj)
    
     pred = output[mask].max(1)[1]
    
     acc = pred.eq(labels[mask]).sum().item() / mask.sum().item()
    
     return acc
    
  
    
 # 主函数
    
 # 创建图数据集
    
 G, features, labels = create_graph()
    
 adj = nx.adjacency_matrix(G).todense()
    
 adj = torch.FloatTensor(adj)
    
 features = torch.FloatTensor(features)
    
 labels = torch.LongTensor(labels)
    
  
    
 # 训练和测试掩码，前 30 个节点用于训练
    
 train_mask = torch.BoolTensor([True if i < 30 else False for i in range(len(labels))])
    
 test_mask = ~train_mask
    
  
    
 # 初始化模型和优化器
    
 model = GNN(input_dim=features.shape[1], hidden_dim=16, output_dim=2)
    
 optimizer = optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)
    
  
    
 # 训练模型
    
 train(model, optimizer, features, labels, adj, train_mask)
    
  
    
 # 测试模型
    
 train_acc = test(model, features, labels, adj, train_mask)
    
 test_acc = test(model, features, labels, adj, test_mask)
    
 print(f'Train Accuracy: {train_acc:.4f}, Test Accuracy: {test_acc:.4f}')
    
  
    
 # 可视化结果
    
 def plot_graph(G, labels, pred=None):
    
     pos = nx.spring_layout(G)
    
     plt.figure(figsize=(8, 8))
    
     nx.draw(G, pos, with_labels=True, node_color=labels, cmap=plt.cm.rainbow, node_size=500, font_color='white')
    
     if pred is not None:
    
     nx.draw_networkx_nodes(G, pos, node_color=pred, cmap=plt.cm.rainbow, node_size=200, alpha=0.5)
    
     plt.show()
    
  
    
 plot_graph(G, labels.numpy(), pred=model(features, adj).max(1)[1].numpy())