gcn代码详解pytorch

GCN（Graph Convolutional Networks，图卷积网络）是一种用于图像分类、节点分类等图像处理任务的深度学习模型。下面我将介绍如何使用PyTorch实现GCN。

首先，我们需要安装PyTorch和其它必要的库。可以使用以下命令安装：

pip install torch torchvision
pip install numpy scipy scikit-learn

接下来，我们需要定义一个GCN模型。以下是一个简单的实现：

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

class GCN(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super(GCN, self).__init__()
        self.fc1 = nn.Linear(input_dim, hidden_dim)
        self.fc2 = nn.Linear(hidden_dim, output_dim)
    
    def forward(self, x, adj):
        x = F.relu(self.fc1(torch.mm(adj, x)))
        x = self.fc2(torch.mm(adj, x))
        return F.log_softmax(x, dim=1)

在上面的代码中，我们定义了一个三层的GCN模型。`input_dim`是输入特征的维度，`hidden_dim`是隐藏层的维度，`output_dim`是输出层的维度。`nn.Linear`是一个线性层，`F.relu`是一个激活函数，`F.log_softmax`是一个softmax函数。

接下来，我们需要定义一个训练函数。以下是一个简单的实现：

def train(model, optimizer, criterion, features, adj, labels, idx_train):
    model.train()
    optimizer.zero_grad()
    output = model(features, adj)
    loss = criterion(output[idx_train], labels[idx_train])
    loss.backward()
    optimizer.step()
    return model, optimizer, loss.item()

在上面的代码中，我们定义了一个训练函数。`features`是输入特征，`adj`是邻接矩阵，`labels`是标签，`idx_train`是训练样本的索引。我们使用`model.train()`将模型切换到训练模式，然后使用`optimizer.zero_grad()`将梯度清零，使用`model(features, adj)`计算输出，使用`criterion(output[idx_train], labels[idx_train])`计算损失，使用`loss.backward()`计算梯度，使用`optimizer.step()`更新参数。

接下来，我们需要定义一个测试函数。以下是一个简单的实现：

def test(model, features, adj, labels, idx_test):
    model.eval()
    output = model(features, adj)
    _, preds = torch.max(output, dim=1)
    correct = torch.sum(preds[idx_test] == labels[idx_test])
    acc = correct.item() / len(idx_test)
    return acc

在上面的代码中，我们定义了一个测试函数。`features`是输入特征，`adj`是邻接矩阵，`labels`是标签，`idx_test`是测试样本的索引。我们使用`model.eval()`将模型切换到测试模式，然后使用`model(features, adj)`计算输出，使用`torch.max`计算最大值，使用`torch.sum`计算正确的预测数量，使用`acc = correct.item() / len(idx_test)`计算准确率。

以下是一个完整的GCN模型的实现：

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

class GCN(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super(GCN, self).__init__()
        self.fc1 = nn.Linear(input_dim, hidden_dim)
        self.fc2 = nn.Linear(hidden_dim, output_dim)
    
    def forward(self, x, adj):
        x = F.relu(self.fc1(torch.mm(adj, x)))
        x = self.fc2(torch.mm(adj, x))
        return F.log_softmax(x, dim=1)

def train(model, optimizer, criterion, features, adj, labels, idx_train):
    model.train()
    optimizer.zero_grad()
    output = model(features, adj)
    loss = criterion(output[idx_train], labels[idx_train])
    loss.backward()
    optimizer.step()
    return model, optimizer, loss.item()

def test(model, features, adj, labels, idx_test):
    model.eval()
    output = model(features, adj)
    _, preds = torch.max(output, dim=1)
    correct = torch.sum(preds[idx_test] == labels[idx_test])
    acc = correct.item() / len(idx_test)
    return acc

接下来，我们需要加载数据。以下是一个简单的实现：

import numpy as np

def load_data():
    adj = np.array([[0, 1, 1, 0],
                    [1, 0, 1, 0],
                    [1, 1, 0, 1],
                    [0, 0, 1, 0]])
    features = np.array([[0, 1, 0],
                         [1, 0, 0],
                         [0, 0, 1],
                         [1, 0, 0]])
    labels = np.array([0, 1, 2, 0])
    idx_train = np.array([0, 1, 2])
    idx_test = np.array([3])
    return adj, features, labels, idx_train, idx_test

在上面的代码中，我们定义了一个简单的图。`adj`是邻接矩阵，`features`是输入特征，`labels`是标签，`idx_train`是训练样本的索引，`idx_test`是测试样本的索引。

接下来，我们需要训练模型。以下是一个简单的实现：

import torch.optim as optim

adj, features, labels, idx_train, idx_test = load_data()
model = GCN(input_dim=features.shape[1], hidden_dim=16, output_dim=labels.max()+1)
optimizer = optim.Adam(model.parameters(), lr=0.01)
criterion = nn.CrossEntropyLoss()

for epoch in range(100):
    model, optimizer, loss = train(model, optimizer, criterion, features, adj, labels, idx_train)
    acc = test(model, features, adj, labels, idx_test)
    print('Epoch: {:03d}, Loss: {:.4f}, Acc: {:.4f}'.format(epoch, loss, acc))

在上面的代码中，我们定义了一个优化器和一个损失函数。然后，我们使用一个循环来训练模型，并使用`test`函数测试模型。我们使用`print`函数打印训练和测试的损失和准确率。

以上就是使用PyTorch实现GCN的一些基本步骤。当然，这只是一个简单的实现，实际中还有很多需要改进的地方。希望能对你有所帮助！