写一个CNN和GNN相结合的图像识别代码

以下是一个简单的CNN和GNN相结合的图像识别代码，使用PyTorch实现：

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch_geometric.nn import GCNConv

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=5)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=5)
        self.fc1 = nn.Linear(1024, 128)
        self.fc2 = nn.Linear(128, 10)
        self.gc1 = GCNConv(64, 64)

    def forward(self, x, edge_index):
        x = F.relu(self.conv1(x))
        x = F.max_pool2d(x, 2)
        x = F.relu(self.conv2(x))
        x = F.max_pool2d(x, 2)
        x = x.view(-1, 1024)
        x = F.relu(self.fc1(x))
        x = F.dropout(x, training=self.training)
        x = self.fc2(x)
        x = F.log_softmax(x, dim=1)
        x = F.relu(self.gc1(x, edge_index))
        return x

这个模型的输入是一张28x28的灰度图像，输出是一个长度为10的向量，表示对每个数字的预测概率。在CNN部分，我们定义了两个卷积层和两个全连接层。在GNN部分，我们使用了一个GCNConv层来对CNN部分提取的特征进行进一步处理。在forward函数中，我们首先对输入图像进行卷积和池化操作，然后将其展开为一个向量。接着，我们将该向量输入到全连接层中进行处理。最后，我们将得到的向量输入到GCNConv层中进行图像处理。

在训练模型时，我们需要选择一个损失函数和优化器。常用的损失函数包括交叉熵损失和均方误差损失。常用的优化器包括随机梯度下降、Adam和Adagrad。以下是一个示例训练代码：

import torch.optim as optim
from torch_geometric.datasets import MNIST
from torch_geometric.data import DataLoader

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = Net().to(device)
optimizer = optim.Adam(model.parameters(), lr=0.01)
criterion = nn.CrossEntropyLoss()

train_dataset = MNIST(root='/tmp/MNIST', train=True, download=True)
test_dataset = MNIST(root='/tmp/MNIST', train=False, download=True)

train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)

def train(epoch):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()
        output = model(data, data.edge_index)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()

def test():
    model.eval()
    test_loss = 0
    correct = 0
    with torch.no_grad():
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            output = model(data, data.edge_index)
            test_loss += criterion(output, target).item()
            pred = output.argmax(dim=1, keepdim=True)
            correct += pred.eq(target.view_as(pred)).sum().item()

    test_loss /= len(test_loader.dataset)
    print('Test set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)'.format(
        test_loss, correct, len(test_loader.dataset),
        100. * correct / len(test_loader.dataset)))

for epoch in range(1, 11):
    train(epoch)
    test()

在训练过程中，我们首先将模型转移到GPU上（如果有的话），然后定义了一个Adam优化器和一个交叉熵损失函数。接着，我们加载MNIST数据集，并使用DataLoader类将其分成小批量。在每个训练轮次中，我们遍历所有小批量，并使用模型进行前向传播、计算损失、计算梯度和更新权重。在测试过程中，我们关闭了梯度计算，并计算了模型在测试集上的准确率。