要求利用python编写满足以下要求的代码：1.利用torchvision下的MNIST数据集实现卷积神经网络手写数据识别。2.先下载数据，并以0.05的采样率得到测试数据和训练数据3.采用SGD的优化方法4.能够打印出1-50epoch下测试集和训练集的损失函数值的图像5.绘制在1-50epoch下训练集和测试集的准确率，显示在一张图中6.显示所有图片

好的，我已经记录下来了您的要求。以下是Python代码实现：

import torch
import torchvision
import matplotlib.pyplot as plt

# 设置随机种子，保证实验的可重复性
torch.manual_seed(1)

# 下载MNIST数据集
train_dataset = torchvision.datasets.MNIST(root='./data', train=True, transform=torchvision.transforms.ToTensor(), download=True)
test_dataset = torchvision.datasets.MNIST(root='./data', train=False, transform=torchvision.transforms.ToTensor(), download=True)

# 以0.05的采样率得到测试数据和训练数据
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=32, sampler=torch.utils.data.sampler.SubsetRandomSampler(range(0, len(train_dataset), 20)))
test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=32, sampler=torch.utils.data.sampler.SubsetRandomSampler(range(0, len(test_dataset), 20)))

# 定义卷积神经网络模型
class CNN(torch.nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = torch.nn.Conv2d(1, 16, kernel_size=5, padding=2)
        self.conv2 = torch.nn.Conv2d(16, 32, kernel_size=5, padding=2)
        self.pool = torch.nn.MaxPool2d(kernel_size=2, stride=2)
        self.fc1 = torch.nn.Linear(32 * 7 * 7, 1024)
        self.fc2 = torch.nn.Linear(1024, 10)

    def forward(self, x):
        x = self.pool(torch.relu(self.conv1(x)))
        x = self.pool(torch.relu(self.conv2(x)))
        x = x.view(-1, 32 * 7 * 7)
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# 实例化模型和损失函数
model = CNN()
criterion = torch.nn.CrossEntropyLoss()

# 设置优化器
optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

# 训练模型
train_loss_list = []
test_loss_list = []
train_acc_list = []
test_acc_list = []
for epoch in range(50):
    # 训练模型
    train_loss = 0.0
    correct = 0
    total = 0
    for i, (inputs, labels) in enumerate(train_loader):
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        train_loss += loss.item()
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()
    train_loss_list.append(train_loss / len(train_loader))
    train_acc_list.append(100 * correct / total)

    # 测试模型
    test_loss = 0.0
    correct = 0
    total = 0
    with torch.no_grad():
        for inputs, labels in test_loader:
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            test_loss += loss.item()
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    test_loss_list.append(test_loss / len(test_loader))
    test_acc_list.append(100 * correct / total)

    # 打印训练和测试损失函数值
    print('Epoch %d Training Loss: %.3f Test Loss: %.3f' % (epoch + 1, train_loss_list[-1], test_loss_list[-1]))

# 绘制训练和测试损失函数值图像
plt.plot(train_loss_list, label='Training Loss')
plt.plot(test_loss_list, label='Test Loss')
plt.legend()
plt.show()

# 绘制训练和测试准确率图像
plt.plot(train_acc_list, label='Training Accuracy')
plt.plot(test_acc_list, label='Test Accuracy')
plt.legend()
plt.show()

# 显示所有图片
for i, (inputs, labels) in enumerate(train_loader):
    for j in range(inputs.size(0)):
        plt.imshow(inputs[j][0], cmap='gray')
        plt.show()