深度学习框架pytorch通过卷积神经网络实现mnist手写数据集的识别，卷积层数、卷积核数、卷积核大小、padding值、stride值、学习率、优化方式等均可自己选择，计算模型精确率，训练误差，测试误差，并以图表形式显示

好的，下面是一个使用PyTorch框架通过卷积神经网络（CNN）实现MNIST手写数字数据集识别的示例代码。这个示例包括卷积层数、卷积核数、卷积核大小、padding值、stride值、学习率、优化方式等参数的设置，并计算模型精确率、训练误差和测试误差，最后以图表形式显示结果。
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt

# 定义超参数
batch_size = 64
learning_rate = 0.01
num_epochs = 10

# 数据预处理
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))
])

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

train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False)

# 定义卷积神经网络
class ConvNet(nn.Module):
def __init__(self):
super(ConvNet, self).__init__()
self.layer1 = nn.Sequential(
nn.Conv2d(1, 32, kernel_size=3, padding=1, stride=1),
nn.BatchNorm2d(32),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2, stride=2)
)
self.layer2 = nn.Sequential(
nn.Conv2d(32, 64, kernel_size=3, padding=1, stride=1),
nn.BatchNorm2d(64),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2, stride=2)
)
self.fc = nn.Linear(7 * 7 * 64, 10)

def forward(self, x):
out = self.layer1(x)
out = self.layer2(out)
out = out.reshape(out.size(0), -1)
out = self.fc(out)
return out

model = ConvNet()

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# 训练模型
total_step = len(train_loader)
train_losses = []
test_losses = []
for epoch in range(num_epochs):
model.train()
running_loss = 0.0
for images, labels in train_loader:
outputs = model(images)
loss = criterion(outputs, labels)

optimizer.zero_grad()
loss.backward()
optimizer.step()

running_loss += loss.item()

avg_train_loss = running_loss / len(train_loader)
train_losses.append(avg_train_loss)

# 测试模型
model.eval()
with torch.no_grad():
correct = 0
total = 0
test_loss = 0.0
for images, labels in test_loader:
outputs = model(images)
loss = criterion(outputs, labels)
test_loss += loss.item()
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()

avg_test_loss = test_loss / len(test_loader)
test_losses.append(avg_test_loss)
accuracy = 100 * correct / total

print(f'Epoch [{epoch+1}/{num_epochs}], Train Loss: {avg_train_loss:.4f}, Test Loss: {avg_test_loss:.4f}, Accuracy: {accuracy:.2f}%')

# 绘制训练和测试误差图
plt.plot(range(1, num_epochs+1), train_losses, label='Train Loss')
plt.plot(range(1, num_epochs+1), test_losses, label='Test Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()
plt.show()
登录后复制