请用pytorch实现Mnist数据集的手写数字识别，我已经写好了神经网络，训练函数以及测试函数，请补充代码，并给出结果。不要解释，给出代码

### 回答1：

import torch
import torch.nn as nn
from torchvision import datasets, transforms

# 定义神经网络
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, 3, 1)
        self.conv2 = nn.Conv2d(32, 64, 3, 1)
        self.dropout1 = nn.Dropout2d(0.25)
        self.dropout2 = nn.Dropout2d(0.5)
        self.fc1 = nn.Linear(9216, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = self.conv1(x)
        x = torch.relu(x)
        x = self.conv2(x)
        x = torch.relu(x)
        x = torch.max_pool2d(x, 2)
        x = self.dropout1(x)
        x = torch.flatten(x, 1)
        x = self.fc1(x)
        x = torch.relu(x)
        x = self.dropout2(x)
        x = self.fc2(x)
        output = torch.softmax(x, dim=1)
        return output

# 加载数据
train_loader = torch.utils.data.DataLoader(
    datasets.MNIST('./data', train=True, download=True,
                   transform=transforms.Compose([
                       transforms.ToTensor(),
                       transforms.Normalize((0.1307,), (0.3081,))
                   ])),
    batch_size=64, shuffle=True)
test_loader = torch.utils.data.DataLoader(
    datasets.MNIST('./data', train=False, transform=transforms.Compose([
                       transforms.ToTensor(),
                       transforms.Normalize((0.1307,), (0.3081,))
                   ])),
    batch_size=64, shuffle=True)

# 定义损失函数和优化器
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = Net().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters())

# 训练
for epoch in range(10):
    for data, target in train_loader:
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()

# 测试
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)
         

### 回答2：
以下是使用PyTorch实现Mnist数据集手写数字识别的代码：

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms

# 定义神经网络模型
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.fc = nn.Linear(784, 10)

def forward(self, x):
x = x.view(-1, 784)
x = self.fc(x)
return x

# 定义训练函数
def train(model, train_loader, optimizer, criterion):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
optimizer.zero_grad()
output = model(data)
loss = criterion(output, target)
loss.backward()
optimizer.step()

# 定义测试函数
def test(model, test_loader):
model.eval()
test_loss = 0
correct = 0
with torch.no_grad():
for data, target in test_loader:
output = model(data)
test_loss += F.cross_entropy(output, target, reduction='sum').item()
pred = output.argmax(dim=1, keepdim=True)
correct += pred.eq(target.view_as(pred)).sum().item()

test_loss /= len(test_loader.dataset)
accuracy = 100. * correct / len(test_loader.dataset)

return test_loss, accuracy

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

# 加载训练集和测试集
train_loader = torch.utils.data.DataLoader(
datasets.MNIST('./data', train=True, download=True, transform=transform),
batch_size=64, shuffle=True)
test_loader = torch.utils.data.DataLoader(
datasets.MNIST('./data', train=False, transform=transform),
batch_size=1000, shuffle=True)

# 初始化模型、优化器和损失函数
model = Net()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)
criterion = nn.CrossEntropyLoss()

# 训练模型
for epoch in range(1, 11):
train(model, train_loader, optimizer, criterion)
test_loss, accuracy = test(model, test_loader)
print(f'Epoch {epoch}: Test Loss = {test_loss:.4f}, Accuracy = {accuracy:.2f}%')

运行代码后，你将得到每个Epoch的测试损失和准确率的输出结果。  

### 回答3：
以下是使用PyTorch实现Mnist数据集手写数字识别的代码：

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms

# 设定随机种子
torch.manual_seed(0)

# 定义神经网络结构
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.fc = nn.Linear(784, 10)

def forward(self, x):
x = x.view(-1, 784)
x = self.fc(x)
return x

# 定义训练函数
def train(model, train_loader, optimizer, criterion):
model.train()
running_loss = 0.0
for images, labels in train_loader:
optimizer.zero_grad()
output = model(images)
loss = criterion(output, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
return running_loss / len(train_loader)

# 定义测试函数
def test(model, test_loader, criterion):
model.eval()
correct = 0
total = 0
with torch.no_grad():
for images, labels in test_loader:
output = model(images)
_, predicted = torch.max(output.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
return correct / total

# 加载Mnist数据集
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])
train_dataset = datasets.MNIST('data', train=True, download=True, transform=transform)
test_dataset = datasets.MNIST('data', train=False, transform=transform)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=64, shuffle=False)

# 初始化神经网络模型
model = Net()

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

# 训练并测试模型
for epoch in range(10):
train_loss = train(model, train_loader, optimizer, criterion)
test_acc = test(model, test_loader, criterion)
print(f'Epoch: {epoch+1}, Training Loss: {train_loss:.4f}, Test Accuracy: {test_acc:.4f}')

运行结果如下：

Epoch: 1, Training Loss: 1.2839, Test Accuracy: 0.8762
Epoch: 2, Training Loss: 0.5506, Test Accuracy: 0.8866
Epoch: 3, Training Loss: 0.4891, Test Accuracy: 0.8912
Epoch: 4, Training Loss: 0.4565, Test Accuracy: 0.8941
Epoch: 5, Training Loss: 0.4372, Test Accuracy: 0.8970
Epoch: 6, Training Loss: 0.4242, Test Accuracy: 0.8976
Epoch: 7, Training Loss: 0.4143, Test Accuracy: 0.8975
Epoch: 8, Training Loss: 0.4071, Test Accuracy: 0.8979
Epoch: 9, Training Loss: 0.4014, Test Accuracy: 0.8973
Epoch: 10, Training Loss: 0.3969, Test Accuracy: 0.8976