在pytorch平台上使用完整python代码使用googlenet，resnet这两个经典的神经网络实现手写数字识别并给出运行结果及图像，关键是在GPU上运行出图像

好的，我明白了。为了使用GoogleNet和ResNet实现手写数字识别，我们需要引入PyTorch库和一些其他必要的库。下面是完整的Python代码：

import torch
import torch.nn as nn
import torchvision

# 定义网络结构
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        
        self.googlenet = torchvision.models.googlenet(num_classes=10)
        self.resnet = torchvision.models.resnet18(num_classes=10)

    def forward(self, x):
        
        x1 = self.googlenet(x)
        x2 = self.resnet(x)
        
        return x1, x2

# 加载MNIST手写数字数据集
transform = torchvision.transforms.Compose([
    torchvision.transforms.ToTensor(),
    torchvision.transforms.Normalize((0.1307,), (0.3081,))
])
train_set = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(train_set, batch_size=64, shuffle=True)

# 初始化网络和优化器
net = Net()
net.cuda()

criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters(), lr=0.001)

# 训练网络
for epoch in range(10):
    running_loss = 0.0
    for i, data in enumerate(train_loader, 0):
        inputs, labels = data
        inputs, labels = inputs.cuda(), labels.cuda()

        optimizer.zero_grad()

        outputs1, outputs2 = net(inputs)
        loss1 = criterion(outputs1, labels)
        loss2 = criterion(outputs2, labels)
        loss = loss1 + loss2
        loss.backward()

        optimizer.step()

        running_loss += loss.item()

    print('Epoch %d loss: %.3f' % (epoch + 1, running_loss / len(train_loader)))

# 使用测试集对网络进行测试并展示识别结果
test_set = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)
test_loader = torch.utils.data.DataLoader(test_set, batch_size=8, shuffle=False)

for data in test_loader:
    images, labels = data
    images, labels = images.cuda(), labels.cuda()

    outputs1, outputs2 = net(images)
    _, predicted1 = torch.max(outputs1.data, 1)
    _, predicted2 = torch.max(outputs2.data, 1)

    for i in range(8):
        image = images[i].cpu().numpy()
        image = image.transpose(1, 2, 0)
        image = image * 0.3081 + 0.1307
        label = labels[i].cpu().numpy()
        pred_label1 = predicted1[i].cpu().numpy()
        pred_label2 = predicted2[i].cpu().numpy()

        print('Ground truth label: %d, Predicted label (GoogleNet): %d, Predicted label (ResNet): %d' % (label, pred_label1, pred_label2))
        
        plt.imshow(image)
        plt.show()

这段代码定义了一个名为Net的类，其中包含一个GoogleNet和一个ResNet模型，这对于手写数字识别应该足够了。然后我们使用PyTorch内置的MNIST数据集加载手写数字图像，并将其提供给一个数据加载器。之后我们训练了这个网络，然后使用测试集对其进行测试，并将每个数字的原标签、GoogleNet预测的标签和ResNet预测的标签打印出来，并将每个数字的图像展示出来。